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                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1372                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377                 {
1378                         uint32_t _flags_save_string = ndr->flags;
1379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1380                         if (r->servername) {
1381                                 uint32_t _relative_save_offset;
1382                                 _relative_save_offset = ndr->offset;
1383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1384                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1385                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1388                                 ndr->offset = _relative_save_offset;
1389                         }
1390                         ndr->flags = _flags_save_string;
1391                 }
1392                 {
1393                         uint32_t _flags_save_string = ndr->flags;
1394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1395                         if (r->printername) {
1396                                 uint32_t _relative_save_offset;
1397                                 _relative_save_offset = ndr->offset;
1398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1399                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1400                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1403                                 ndr->offset = _relative_save_offset;
1404                         }
1405                         ndr->flags = _flags_save_string;
1406                 }
1407                 {
1408                         uint32_t _flags_save_string = ndr->flags;
1409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1410                         if (r->sharename) {
1411                                 uint32_t _relative_save_offset;
1412                                 _relative_save_offset = ndr->offset;
1413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1414                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1415                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1418                                 ndr->offset = _relative_save_offset;
1419                         }
1420                         ndr->flags = _flags_save_string;
1421                 }
1422                 {
1423                         uint32_t _flags_save_string = ndr->flags;
1424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1425                         if (r->portname) {
1426                                 uint32_t _relative_save_offset;
1427                                 _relative_save_offset = ndr->offset;
1428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1429                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1430                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1433                                 ndr->offset = _relative_save_offset;
1434                         }
1435                         ndr->flags = _flags_save_string;
1436                 }
1437                 {
1438                         uint32_t _flags_save_string = ndr->flags;
1439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1440                         if (r->drivername) {
1441                                 uint32_t _relative_save_offset;
1442                                 _relative_save_offset = ndr->offset;
1443                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1444                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1445                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1446                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1447                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1448                                 ndr->offset = _relative_save_offset;
1449                         }
1450                         ndr->flags = _flags_save_string;
1451                 }
1452                 {
1453                         uint32_t _flags_save_string = ndr->flags;
1454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1455                         if (r->comment) {
1456                                 uint32_t _relative_save_offset;
1457                                 _relative_save_offset = ndr->offset;
1458                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1459                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1460                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1461                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1462                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1463                                 ndr->offset = _relative_save_offset;
1464                         }
1465                         ndr->flags = _flags_save_string;
1466                 }
1467                 {
1468                         uint32_t _flags_save_string = ndr->flags;
1469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1470                         if (r->location) {
1471                                 uint32_t _relative_save_offset;
1472                                 _relative_save_offset = ndr->offset;
1473                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1474                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1475                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1476                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1477                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1478                                 ndr->offset = _relative_save_offset;
1479                         }
1480                         ndr->flags = _flags_save_string;
1481                 }
1482                 if (r->devmode) {
1483                         uint32_t _relative_save_offset;
1484                         _relative_save_offset = ndr->offset;
1485                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1486                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1487                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1488                         {
1489                                 struct ndr_pull *_ndr_devmode;
1490                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1491                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1492                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1493                         }
1494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1495                         ndr->offset = _relative_save_offset;
1496                 }
1497                 {
1498                         uint32_t _flags_save_string = ndr->flags;
1499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1500                         if (r->sepfile) {
1501                                 uint32_t _relative_save_offset;
1502                                 _relative_save_offset = ndr->offset;
1503                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1504                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1505                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1506                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1507                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1508                                 ndr->offset = _relative_save_offset;
1509                         }
1510                         ndr->flags = _flags_save_string;
1511                 }
1512                 {
1513                         uint32_t _flags_save_string = ndr->flags;
1514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1515                         if (r->printprocessor) {
1516                                 uint32_t _relative_save_offset;
1517                                 _relative_save_offset = ndr->offset;
1518                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1519                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1520                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1521                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1522                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1523                                 ndr->offset = _relative_save_offset;
1524                         }
1525                         ndr->flags = _flags_save_string;
1526                 }
1527                 {
1528                         uint32_t _flags_save_string = ndr->flags;
1529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1530                         if (r->datatype) {
1531                                 uint32_t _relative_save_offset;
1532                                 _relative_save_offset = ndr->offset;
1533                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1534                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1535                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1536                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1537                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1538                                 ndr->offset = _relative_save_offset;
1539                         }
1540                         ndr->flags = _flags_save_string;
1541                 }
1542                 {
1543                         uint32_t _flags_save_string = ndr->flags;
1544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1545                         if (r->parameters) {
1546                                 uint32_t _relative_save_offset;
1547                                 _relative_save_offset = ndr->offset;
1548                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1549                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1550                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1551                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1552                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1553                                 ndr->offset = _relative_save_offset;
1554                         }
1555                         ndr->flags = _flags_save_string;
1556                 }
1557                 if (r->secdesc) {
1558                         uint32_t _relative_save_offset;
1559                         _relative_save_offset = ndr->offset;
1560                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1561                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1562                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1563                         {
1564                                 struct ndr_pull *_ndr_secdesc;
1565                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1566                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1567                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1568                         }
1569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1570                         ndr->offset = _relative_save_offset;
1571                 }
1572         }
1573         return NDR_ERR_SUCCESS;
1574 }
1575
1576 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1577 {
1578         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1579         ndr->depth++;
1580         ndr_print_ptr(ndr, "servername", r->servername);
1581         ndr->depth++;
1582         if (r->servername) {
1583                 ndr_print_string(ndr, "servername", r->servername);
1584         }
1585         ndr->depth--;
1586         ndr_print_ptr(ndr, "printername", r->printername);
1587         ndr->depth++;
1588         if (r->printername) {
1589                 ndr_print_string(ndr, "printername", r->printername);
1590         }
1591         ndr->depth--;
1592         ndr_print_ptr(ndr, "sharename", r->sharename);
1593         ndr->depth++;
1594         if (r->sharename) {
1595                 ndr_print_string(ndr, "sharename", r->sharename);
1596         }
1597         ndr->depth--;
1598         ndr_print_ptr(ndr, "portname", r->portname);
1599         ndr->depth++;
1600         if (r->portname) {
1601                 ndr_print_string(ndr, "portname", r->portname);
1602         }
1603         ndr->depth--;
1604         ndr_print_ptr(ndr, "drivername", r->drivername);
1605         ndr->depth++;
1606         if (r->drivername) {
1607                 ndr_print_string(ndr, "drivername", r->drivername);
1608         }
1609         ndr->depth--;
1610         ndr_print_ptr(ndr, "comment", r->comment);
1611         ndr->depth++;
1612         if (r->comment) {
1613                 ndr_print_string(ndr, "comment", r->comment);
1614         }
1615         ndr->depth--;
1616         ndr_print_ptr(ndr, "location", r->location);
1617         ndr->depth++;
1618         if (r->location) {
1619                 ndr_print_string(ndr, "location", r->location);
1620         }
1621         ndr->depth--;
1622         ndr_print_ptr(ndr, "devmode", r->devmode);
1623         ndr->depth++;
1624         if (r->devmode) {
1625                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1626         }
1627         ndr->depth--;
1628         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1629         ndr->depth++;
1630         if (r->sepfile) {
1631                 ndr_print_string(ndr, "sepfile", r->sepfile);
1632         }
1633         ndr->depth--;
1634         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1635         ndr->depth++;
1636         if (r->printprocessor) {
1637                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1638         }
1639         ndr->depth--;
1640         ndr_print_ptr(ndr, "datatype", r->datatype);
1641         ndr->depth++;
1642         if (r->datatype) {
1643                 ndr_print_string(ndr, "datatype", r->datatype);
1644         }
1645         ndr->depth--;
1646         ndr_print_ptr(ndr, "parameters", r->parameters);
1647         ndr->depth++;
1648         if (r->parameters) {
1649                 ndr_print_string(ndr, "parameters", r->parameters);
1650         }
1651         ndr->depth--;
1652         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1653         ndr->depth++;
1654         if (r->secdesc) {
1655                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1656         }
1657         ndr->depth--;
1658         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1659         ndr_print_uint32(ndr, "priority", r->priority);
1660         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1661         ndr_print_uint32(ndr, "starttime", r->starttime);
1662         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1663         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1664         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1665         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1666         ndr->depth--;
1667 }
1668
1669 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1670 {
1671         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1672 }
1673
1674 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1675 {
1676         if (ndr_flags & NDR_SCALARS) {
1677                 NDR_CHECK(ndr_push_align(ndr, 4));
1678                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1679         }
1680         if (ndr_flags & NDR_BUFFERS) {
1681                 if (r->secdesc) {
1682                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1683                         {
1684                                 struct ndr_push *_ndr_secdesc;
1685                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1686                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1687                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1688                         }
1689                 }
1690         }
1691         return NDR_ERR_SUCCESS;
1692 }
1693
1694 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1695 {
1696         uint32_t _ptr_secdesc;
1697         TALLOC_CTX *_mem_save_secdesc_0;
1698         if (ndr_flags & NDR_SCALARS) {
1699                 NDR_CHECK(ndr_pull_align(ndr, 4));
1700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1701                 if (_ptr_secdesc) {
1702                         NDR_PULL_ALLOC(ndr, r->secdesc);
1703                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1704                 } else {
1705                         r->secdesc = NULL;
1706                 }
1707         }
1708         if (ndr_flags & NDR_BUFFERS) {
1709                 if (r->secdesc) {
1710                         uint32_t _relative_save_offset;
1711                         _relative_save_offset = ndr->offset;
1712                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1713                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1714                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1715                         {
1716                                 struct ndr_pull *_ndr_secdesc;
1717                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1718                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1719                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1720                         }
1721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1722                         ndr->offset = _relative_save_offset;
1723                 }
1724         }
1725         return NDR_ERR_SUCCESS;
1726 }
1727
1728 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1729 {
1730         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1731         ndr->depth++;
1732         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1733         ndr->depth++;
1734         if (r->secdesc) {
1735                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1736         }
1737         ndr->depth--;
1738         ndr->depth--;
1739 }
1740
1741 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
1742 {
1743         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
1744 }
1745
1746 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1747 {
1748         if (ndr_flags & NDR_SCALARS) {
1749                 NDR_CHECK(ndr_push_align(ndr, 4));
1750                 {
1751                         uint32_t _flags_save_string = ndr->flags;
1752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1753                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1754                         ndr->flags = _flags_save_string;
1755                 }
1756                 {
1757                         uint32_t _flags_save_string = ndr->flags;
1758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1759                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1760                         ndr->flags = _flags_save_string;
1761                 }
1762                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1763         }
1764         if (ndr_flags & NDR_BUFFERS) {
1765                 {
1766                         uint32_t _flags_save_string = ndr->flags;
1767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1768                         if (r->printername) {
1769                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1770                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1771                         }
1772                         ndr->flags = _flags_save_string;
1773                 }
1774                 {
1775                         uint32_t _flags_save_string = ndr->flags;
1776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1777                         if (r->servername) {
1778                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1779                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783         }
1784         return NDR_ERR_SUCCESS;
1785 }
1786
1787 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1788 {
1789         uint32_t _ptr_printername;
1790         TALLOC_CTX *_mem_save_printername_0;
1791         uint32_t _ptr_servername;
1792         TALLOC_CTX *_mem_save_servername_0;
1793         if (ndr_flags & NDR_SCALARS) {
1794                 NDR_CHECK(ndr_pull_align(ndr, 4));
1795                 {
1796                         uint32_t _flags_save_string = ndr->flags;
1797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1798                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1799                         if (_ptr_printername) {
1800                                 NDR_PULL_ALLOC(ndr, r->printername);
1801                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1802                         } else {
1803                                 r->printername = NULL;
1804                         }
1805                         ndr->flags = _flags_save_string;
1806                 }
1807                 {
1808                         uint32_t _flags_save_string = ndr->flags;
1809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1811                         if (_ptr_servername) {
1812                                 NDR_PULL_ALLOC(ndr, r->servername);
1813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1814                         } else {
1815                                 r->servername = NULL;
1816                         }
1817                         ndr->flags = _flags_save_string;
1818                 }
1819                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1820         }
1821         if (ndr_flags & NDR_BUFFERS) {
1822                 {
1823                         uint32_t _flags_save_string = ndr->flags;
1824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1825                         if (r->printername) {
1826                                 uint32_t _relative_save_offset;
1827                                 _relative_save_offset = ndr->offset;
1828                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1829                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1830                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1831                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1832                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1833                                 ndr->offset = _relative_save_offset;
1834                         }
1835                         ndr->flags = _flags_save_string;
1836                 }
1837                 {
1838                         uint32_t _flags_save_string = ndr->flags;
1839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1840                         if (r->servername) {
1841                                 uint32_t _relative_save_offset;
1842                                 _relative_save_offset = ndr->offset;
1843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1844                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1845                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1848                                 ndr->offset = _relative_save_offset;
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852         }
1853         return NDR_ERR_SUCCESS;
1854 }
1855
1856 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1857 {
1858         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1859         ndr->depth++;
1860         ndr_print_ptr(ndr, "printername", r->printername);
1861         ndr->depth++;
1862         if (r->printername) {
1863                 ndr_print_string(ndr, "printername", r->printername);
1864         }
1865         ndr->depth--;
1866         ndr_print_ptr(ndr, "servername", r->servername);
1867         ndr->depth++;
1868         if (r->servername) {
1869                 ndr_print_string(ndr, "servername", r->servername);
1870         }
1871         ndr->depth--;
1872         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1873         ndr->depth--;
1874 }
1875
1876 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
1877 {
1878         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
1879 }
1880
1881 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1882 {
1883         if (ndr_flags & NDR_SCALARS) {
1884                 NDR_CHECK(ndr_push_align(ndr, 4));
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1889                         ndr->flags = _flags_save_string;
1890                 }
1891                 {
1892                         uint32_t _flags_save_string = ndr->flags;
1893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1907                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1908                         }
1909                         ndr->flags = _flags_save_string;
1910                 }
1911                 {
1912                         uint32_t _flags_save_string = ndr->flags;
1913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1914                         if (r->portname) {
1915                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1916                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1917                         }
1918                         ndr->flags = _flags_save_string;
1919                 }
1920         }
1921         return NDR_ERR_SUCCESS;
1922 }
1923
1924 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1925 {
1926         uint32_t _ptr_printername;
1927         TALLOC_CTX *_mem_save_printername_0;
1928         uint32_t _ptr_portname;
1929         TALLOC_CTX *_mem_save_portname_0;
1930         if (ndr_flags & NDR_SCALARS) {
1931                 NDR_CHECK(ndr_pull_align(ndr, 4));
1932                 {
1933                         uint32_t _flags_save_string = ndr->flags;
1934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1936                         if (_ptr_printername) {
1937                                 NDR_PULL_ALLOC(ndr, r->printername);
1938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1939                         } else {
1940                                 r->printername = NULL;
1941                         }
1942                         ndr->flags = _flags_save_string;
1943                 }
1944                 {
1945                         uint32_t _flags_save_string = ndr->flags;
1946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1947                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1948                         if (_ptr_portname) {
1949                                 NDR_PULL_ALLOC(ndr, r->portname);
1950                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1951                         } else {
1952                                 r->portname = NULL;
1953                         }
1954                         ndr->flags = _flags_save_string;
1955                 }
1956                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1959         }
1960         if (ndr_flags & NDR_BUFFERS) {
1961                 {
1962                         uint32_t _flags_save_string = ndr->flags;
1963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1964                         if (r->printername) {
1965                                 uint32_t _relative_save_offset;
1966                                 _relative_save_offset = ndr->offset;
1967                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1968                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1969                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1970                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1971                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1972                                 ndr->offset = _relative_save_offset;
1973                         }
1974                         ndr->flags = _flags_save_string;
1975                 }
1976                 {
1977                         uint32_t _flags_save_string = ndr->flags;
1978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1979                         if (r->portname) {
1980                                 uint32_t _relative_save_offset;
1981                                 _relative_save_offset = ndr->offset;
1982                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1983                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1984                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1985                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1987                                 ndr->offset = _relative_save_offset;
1988                         }
1989                         ndr->flags = _flags_save_string;
1990                 }
1991         }
1992         return NDR_ERR_SUCCESS;
1993 }
1994
1995 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1996 {
1997         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1998         ndr->depth++;
1999         ndr_print_ptr(ndr, "printername", r->printername);
2000         ndr->depth++;
2001         if (r->printername) {
2002                 ndr_print_string(ndr, "printername", r->printername);
2003         }
2004         ndr->depth--;
2005         ndr_print_ptr(ndr, "portname", r->portname);
2006         ndr->depth++;
2007         if (r->portname) {
2008                 ndr_print_string(ndr, "portname", r->portname);
2009         }
2010         ndr->depth--;
2011         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2012         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2013         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2014         ndr->depth--;
2015 }
2016
2017 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2018 {
2019         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2020 }
2021
2022 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2023 {
2024         if (ndr_flags & NDR_SCALARS) {
2025                 NDR_CHECK(ndr_push_align(ndr, 4));
2026                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2027         }
2028         if (ndr_flags & NDR_BUFFERS) {
2029         }
2030         return NDR_ERR_SUCCESS;
2031 }
2032
2033 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2034 {
2035         if (ndr_flags & NDR_SCALARS) {
2036                 NDR_CHECK(ndr_pull_align(ndr, 4));
2037                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2038         }
2039         if (ndr_flags & NDR_BUFFERS) {
2040         }
2041         return NDR_ERR_SUCCESS;
2042 }
2043
2044 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2045 {
2046         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2047         ndr->depth++;
2048         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2049         ndr->depth--;
2050 }
2051
2052 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2053 {
2054         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2055 }
2056
2057 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2058 {
2059         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2060         return NDR_ERR_SUCCESS;
2061 }
2062
2063 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2064 {
2065         uint32_t v;
2066         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2067         *r = v;
2068         return NDR_ERR_SUCCESS;
2069 }
2070
2071 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2072 {
2073         ndr_print_uint32(ndr, name, r);
2074         ndr->depth++;
2075         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2076         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2077         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2078         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2079         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2080         ndr->depth--;
2081 }
2082
2083 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2084 {
2085         if (ndr_flags & NDR_SCALARS) {
2086                 NDR_CHECK(ndr_push_align(ndr, 4));
2087                 {
2088                         uint32_t _flags_save_string = ndr->flags;
2089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2090                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2091                         ndr->flags = _flags_save_string;
2092                 }
2093                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2094         }
2095         if (ndr_flags & NDR_BUFFERS) {
2096                 {
2097                         uint32_t _flags_save_string = ndr->flags;
2098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2099                         if (r->guid) {
2100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2102                         }
2103                         ndr->flags = _flags_save_string;
2104                 }
2105         }
2106         return NDR_ERR_SUCCESS;
2107 }
2108
2109 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2110 {
2111         uint32_t _ptr_guid;
2112         TALLOC_CTX *_mem_save_guid_0;
2113         if (ndr_flags & NDR_SCALARS) {
2114                 NDR_CHECK(ndr_pull_align(ndr, 4));
2115                 {
2116                         uint32_t _flags_save_string = ndr->flags;
2117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2119                         if (_ptr_guid) {
2120                                 NDR_PULL_ALLOC(ndr, r->guid);
2121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2122                         } else {
2123                                 r->guid = NULL;
2124                         }
2125                         ndr->flags = _flags_save_string;
2126                 }
2127                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2128         }
2129         if (ndr_flags & NDR_BUFFERS) {
2130                 {
2131                         uint32_t _flags_save_string = ndr->flags;
2132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2133                         if (r->guid) {
2134                                 uint32_t _relative_save_offset;
2135                                 _relative_save_offset = ndr->offset;
2136                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2137                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2138                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2139                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2140                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2141                                 ndr->offset = _relative_save_offset;
2142                         }
2143                         ndr->flags = _flags_save_string;
2144                 }
2145         }
2146         return NDR_ERR_SUCCESS;
2147 }
2148
2149 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2150 {
2151         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2152         ndr->depth++;
2153         ndr_print_ptr(ndr, "guid", r->guid);
2154         ndr->depth++;
2155         if (r->guid) {
2156                 ndr_print_string(ndr, "guid", r->guid);
2157         }
2158         ndr->depth--;
2159         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2160         ndr->depth--;
2161 }
2162
2163 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2164 {
2165         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2166 }
2167
2168 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2169 {
2170         if (ndr_flags & NDR_SCALARS) {
2171                 NDR_CHECK(ndr_push_align(ndr, 4));
2172                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2173         }
2174         if (ndr_flags & NDR_BUFFERS) {
2175                 if (r->devmode) {
2176                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2177                         {
2178                                 struct ndr_push *_ndr_devmode;
2179                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2180                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2181                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2182                         }
2183                 }
2184         }
2185         return NDR_ERR_SUCCESS;
2186 }
2187
2188 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2189 {
2190         uint32_t _ptr_devmode;
2191         TALLOC_CTX *_mem_save_devmode_0;
2192         if (ndr_flags & NDR_SCALARS) {
2193                 NDR_CHECK(ndr_pull_align(ndr, 4));
2194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2195                 if (_ptr_devmode) {
2196                         NDR_PULL_ALLOC(ndr, r->devmode);
2197                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2198                 } else {
2199                         r->devmode = NULL;
2200                 }
2201         }
2202         if (ndr_flags & NDR_BUFFERS) {
2203                 if (r->devmode) {
2204                         uint32_t _relative_save_offset;
2205                         _relative_save_offset = ndr->offset;
2206                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2207                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2208                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2209                         {
2210                                 struct ndr_pull *_ndr_devmode;
2211                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2212                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2213                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2214                         }
2215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2216                         ndr->offset = _relative_save_offset;
2217                 }
2218         }
2219         return NDR_ERR_SUCCESS;
2220 }
2221
2222 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2223 {
2224         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2225         ndr->depth++;
2226         ndr_print_ptr(ndr, "devmode", r->devmode);
2227         ndr->depth++;
2228         if (r->devmode) {
2229                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2230         }
2231         ndr->depth--;
2232         ndr->depth--;
2233 }
2234
2235 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2236 {
2237         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2238         if (ndr_flags & NDR_SCALARS) {
2239                 int level = ndr_push_get_switch_value(ndr, r);
2240                 switch (level) {
2241                         case 0: {
2242                                 NDR_CHECK(ndr_push_align(ndr, 4));
2243                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2244                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2245                         break; }
2246
2247                         case 1: {
2248                                 NDR_CHECK(ndr_push_align(ndr, 4));
2249                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2250                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2251                         break; }
2252
2253                         case 2: {
2254                                 NDR_CHECK(ndr_push_align(ndr, 4));
2255                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2256                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2257                         break; }
2258
2259                         case 3: {
2260                                 NDR_CHECK(ndr_push_align(ndr, 4));
2261                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2262                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2263                         break; }
2264
2265                         case 4: {
2266                                 NDR_CHECK(ndr_push_align(ndr, 4));
2267                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2268                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2269                         break; }
2270
2271                         case 5: {
2272                                 NDR_CHECK(ndr_push_align(ndr, 4));
2273                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2274                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2275                         break; }
2276
2277                         case 6: {
2278                                 NDR_CHECK(ndr_push_align(ndr, 4));
2279                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2280                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2281                         break; }
2282
2283                         case 7: {
2284                                 NDR_CHECK(ndr_push_align(ndr, 4));
2285                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2286                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2287                         break; }
2288
2289                         case 8: {
2290                                 NDR_CHECK(ndr_push_align(ndr, 4));
2291                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2292                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2293                         break; }
2294
2295                         case 9: {
2296                                 NDR_CHECK(ndr_push_align(ndr, 4));
2297                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2298                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2299                         break; }
2300
2301                         default: {
2302                         break; }
2303
2304                 }
2305         }
2306         if (ndr_flags & NDR_BUFFERS) {
2307                 int level = ndr_push_get_switch_value(ndr, r);
2308                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2309                 switch (level) {
2310                         case 0:
2311                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2312                         break;
2313
2314                         case 1:
2315                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2316                         break;
2317
2318                         case 2:
2319                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2320                         break;
2321
2322                         case 3:
2323                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2324                         break;
2325
2326                         case 4:
2327                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2328                         break;
2329
2330                         case 5:
2331                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2332                         break;
2333
2334                         case 6:
2335                         break;
2336
2337                         case 7:
2338                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2339                         break;
2340
2341                         case 8:
2342                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2343                         break;
2344
2345                         case 9:
2346                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2347                         break;
2348
2349                         default:
2350                         break;
2351
2352                 }
2353         }
2354         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2355         return NDR_ERR_SUCCESS;
2356 }
2357
2358 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2359 {
2360         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2361         int level;
2362         level = ndr_pull_get_switch_value(ndr, r);
2363         if (ndr_flags & NDR_SCALARS) {
2364                 switch (level) {
2365                         case 0: {
2366                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2367                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2369                         break; }
2370
2371                         case 1: {
2372                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2373                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2374                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2375                         break; }
2376
2377                         case 2: {
2378                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2379                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2381                         break; }
2382
2383                         case 3: {
2384                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2385                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2386                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2387                         break; }
2388
2389                         case 4: {
2390                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2391                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2392                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2393                         break; }
2394
2395                         case 5: {
2396                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2397                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2398                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2399                         break; }
2400
2401                         case 6: {
2402                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2403                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2404                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2405                         break; }
2406
2407                         case 7: {
2408                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2409                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2410                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2411                         break; }
2412
2413                         case 8: {
2414                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2415                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2416                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2417                         break; }
2418
2419                         case 9: {
2420                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2421                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2422                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2423                         break; }
2424
2425                         default: {
2426                         break; }
2427
2428                 }
2429         }
2430         if (ndr_flags & NDR_BUFFERS) {
2431                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2432                 switch (level) {
2433                         case 0:
2434                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2435                         break;
2436
2437                         case 1:
2438                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2439                         break;
2440
2441                         case 2:
2442                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2443                         break;
2444
2445                         case 3:
2446                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2447                         break;
2448
2449                         case 4:
2450                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2451                         break;
2452
2453                         case 5:
2454                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2455                         break;
2456
2457                         case 6:
2458                         break;
2459
2460                         case 7:
2461                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2462                         break;
2463
2464                         case 8:
2465                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2466                         break;
2467
2468                         case 9:
2469                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2470                         break;
2471
2472                         default:
2473                         break;
2474
2475                 }
2476         }
2477         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2478         return NDR_ERR_SUCCESS;
2479 }
2480
2481 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2482 {
2483         int level;
2484         level = ndr_print_get_switch_value(ndr, r);
2485         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2486         switch (level) {
2487                 case 0:
2488                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2489                 break;
2490
2491                 case 1:
2492                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2493                 break;
2494
2495                 case 2:
2496                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2497                 break;
2498
2499                 case 3:
2500                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2501                 break;
2502
2503                 case 4:
2504                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2505                 break;
2506
2507                 case 5:
2508                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2509                 break;
2510
2511                 case 6:
2512                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2513                 break;
2514
2515                 case 7:
2516                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2517                 break;
2518
2519                 case 8:
2520                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2521                 break;
2522
2523                 case 9:
2524                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2525                 break;
2526
2527                 default:
2528                 break;
2529
2530         }
2531 }
2532
2533 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2534 {
2535         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2536 }
2537
2538 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2539 {
2540         if (ndr_flags & NDR_SCALARS) {
2541                 NDR_CHECK(ndr_push_align(ndr, 4));
2542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2544         }
2545         if (ndr_flags & NDR_BUFFERS) {
2546                 if (r->devmode) {
2547                         {
2548                                 struct ndr_push *_ndr_devmode;
2549                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2550                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2551                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2552                         }
2553                 }
2554         }
2555         return NDR_ERR_SUCCESS;
2556 }
2557
2558 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2559 {
2560         uint32_t _ptr_devmode;
2561         TALLOC_CTX *_mem_save_devmode_0;
2562         if (ndr_flags & NDR_SCALARS) {
2563                 NDR_CHECK(ndr_pull_align(ndr, 4));
2564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2566                 if (_ptr_devmode) {
2567                         NDR_PULL_ALLOC(ndr, r->devmode);
2568                 } else {
2569                         r->devmode = NULL;
2570                 }
2571         }
2572         if (ndr_flags & NDR_BUFFERS) {
2573                 if (r->devmode) {
2574                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2575                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2576                         {
2577                                 struct ndr_pull *_ndr_devmode;
2578                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2579                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2580                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2581                         }
2582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2583                 }
2584         }
2585         return NDR_ERR_SUCCESS;
2586 }
2587
2588 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2589 {
2590         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2591         ndr->depth++;
2592         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);
2593         ndr_print_ptr(ndr, "devmode", r->devmode);
2594         ndr->depth++;
2595         if (r->devmode) {
2596                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2597         }
2598         ndr->depth--;
2599         ndr->depth--;
2600 }
2601
2602 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2603 {
2604         if (ndr_flags & NDR_SCALARS) {
2605                 NDR_CHECK(ndr_push_align(ndr, 4));
2606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2607                 {
2608                         uint32_t _flags_save_string = ndr->flags;
2609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2611                         ndr->flags = _flags_save_string;
2612                 }
2613                 {
2614                         uint32_t _flags_save_string = ndr->flags;
2615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2617                         ndr->flags = _flags_save_string;
2618                 }
2619                 {
2620                         uint32_t _flags_save_string = ndr->flags;
2621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2622                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2623                         ndr->flags = _flags_save_string;
2624                 }
2625                 {
2626                         uint32_t _flags_save_string = ndr->flags;
2627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2628                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2629                         ndr->flags = _flags_save_string;
2630                 }
2631                 {
2632                         uint32_t _flags_save_string = ndr->flags;
2633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2634                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2635                         ndr->flags = _flags_save_string;
2636                 }
2637                 {
2638                         uint32_t _flags_save_string = ndr->flags;
2639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2640                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2641                         ndr->flags = _flags_save_string;
2642                 }
2643                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2648                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2649         }
2650         if (ndr_flags & NDR_BUFFERS) {
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->printer_name) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660                 {
2661                         uint32_t _flags_save_string = ndr->flags;
2662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2663                         if (r->server_name) {
2664                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2666                         }
2667                         ndr->flags = _flags_save_string;
2668                 }
2669                 {
2670                         uint32_t _flags_save_string = ndr->flags;
2671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2672                         if (r->user_name) {
2673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2675                         }
2676                         ndr->flags = _flags_save_string;
2677                 }
2678                 {
2679                         uint32_t _flags_save_string = ndr->flags;
2680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2681                         if (r->document_name) {
2682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2684                         }
2685                         ndr->flags = _flags_save_string;
2686                 }
2687                 {
2688                         uint32_t _flags_save_string = ndr->flags;
2689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2690                         if (r->data_type) {
2691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2693                         }
2694                         ndr->flags = _flags_save_string;
2695                 }
2696                 {
2697                         uint32_t _flags_save_string = ndr->flags;
2698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2699                         if (r->text_status) {
2700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705         }
2706         return NDR_ERR_SUCCESS;
2707 }
2708
2709 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2710 {
2711         uint32_t _ptr_printer_name;
2712         TALLOC_CTX *_mem_save_printer_name_0;
2713         uint32_t _ptr_server_name;
2714         TALLOC_CTX *_mem_save_server_name_0;
2715         uint32_t _ptr_user_name;
2716         TALLOC_CTX *_mem_save_user_name_0;
2717         uint32_t _ptr_document_name;
2718         TALLOC_CTX *_mem_save_document_name_0;
2719         uint32_t _ptr_data_type;
2720         TALLOC_CTX *_mem_save_data_type_0;
2721         uint32_t _ptr_text_status;
2722         TALLOC_CTX *_mem_save_text_status_0;
2723         if (ndr_flags & NDR_SCALARS) {
2724                 NDR_CHECK(ndr_pull_align(ndr, 4));
2725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2726                 {
2727                         uint32_t _flags_save_string = ndr->flags;
2728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2730                         if (_ptr_printer_name) {
2731                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2733                         } else {
2734                                 r->printer_name = NULL;
2735                         }
2736                         ndr->flags = _flags_save_string;
2737                 }
2738                 {
2739                         uint32_t _flags_save_string = ndr->flags;
2740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2742                         if (_ptr_server_name) {
2743                                 NDR_PULL_ALLOC(ndr, r->server_name);
2744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2745                         } else {
2746                                 r->server_name = NULL;
2747                         }
2748                         ndr->flags = _flags_save_string;
2749                 }
2750                 {
2751                         uint32_t _flags_save_string = ndr->flags;
2752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2754                         if (_ptr_user_name) {
2755                                 NDR_PULL_ALLOC(ndr, r->user_name);
2756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2757                         } else {
2758                                 r->user_name = NULL;
2759                         }
2760                         ndr->flags = _flags_save_string;
2761                 }
2762                 {
2763                         uint32_t _flags_save_string = ndr->flags;
2764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2766                         if (_ptr_document_name) {
2767                                 NDR_PULL_ALLOC(ndr, r->document_name);
2768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2769                         } else {
2770                                 r->document_name = NULL;
2771                         }
2772                         ndr->flags = _flags_save_string;
2773                 }
2774                 {
2775                         uint32_t _flags_save_string = ndr->flags;
2776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2778                         if (_ptr_data_type) {
2779                                 NDR_PULL_ALLOC(ndr, r->data_type);
2780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2781                         } else {
2782                                 r->data_type = NULL;
2783                         }
2784                         ndr->flags = _flags_save_string;
2785                 }
2786                 {
2787                         uint32_t _flags_save_string = ndr->flags;
2788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2789                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2790                         if (_ptr_text_status) {
2791                                 NDR_PULL_ALLOC(ndr, r->text_status);
2792                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2793                         } else {
2794                                 r->text_status = NULL;
2795                         }
2796                         ndr->flags = _flags_save_string;
2797                 }
2798                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2803                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2804         }
2805         if (ndr_flags & NDR_BUFFERS) {
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->printer_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2813                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2817                                 ndr->offset = _relative_save_offset;
2818                         }
2819                         ndr->flags = _flags_save_string;
2820                 }
2821                 {
2822                         uint32_t _flags_save_string = ndr->flags;
2823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2824                         if (r->server_name) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2828                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2832                                 ndr->offset = _relative_save_offset;
2833                         }
2834                         ndr->flags = _flags_save_string;
2835                 }
2836                 {
2837                         uint32_t _flags_save_string = ndr->flags;
2838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2839                         if (r->user_name) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2843                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851                 {
2852                         uint32_t _flags_save_string = ndr->flags;
2853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2854                         if (r->document_name) {
2855                                 uint32_t _relative_save_offset;
2856                                 _relative_save_offset = ndr->offset;
2857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2858                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2859                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2862                                 ndr->offset = _relative_save_offset;
2863                         }
2864                         ndr->flags = _flags_save_string;
2865                 }
2866                 {
2867                         uint32_t _flags_save_string = ndr->flags;
2868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2869                         if (r->data_type) {
2870                                 uint32_t _relative_save_offset;
2871                                 _relative_save_offset = ndr->offset;
2872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2873                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2874                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2877                                 ndr->offset = _relative_save_offset;
2878                         }
2879                         ndr->flags = _flags_save_string;
2880                 }
2881                 {
2882                         uint32_t _flags_save_string = ndr->flags;
2883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2884                         if (r->text_status) {
2885                                 uint32_t _relative_save_offset;
2886                                 _relative_save_offset = ndr->offset;
2887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2888                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2889                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2892                                 ndr->offset = _relative_save_offset;
2893                         }
2894                         ndr->flags = _flags_save_string;
2895                 }
2896         }
2897         return NDR_ERR_SUCCESS;
2898 }
2899
2900 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2901 {
2902         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2903         ndr->depth++;
2904         ndr_print_uint32(ndr, "job_id", r->job_id);
2905         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2906         ndr->depth++;
2907         if (r->printer_name) {
2908                 ndr_print_string(ndr, "printer_name", r->printer_name);
2909         }
2910         ndr->depth--;
2911         ndr_print_ptr(ndr, "server_name", r->server_name);
2912         ndr->depth++;
2913         if (r->server_name) {
2914                 ndr_print_string(ndr, "server_name", r->server_name);
2915         }
2916         ndr->depth--;
2917         ndr_print_ptr(ndr, "user_name", r->user_name);
2918         ndr->depth++;
2919         if (r->user_name) {
2920                 ndr_print_string(ndr, "user_name", r->user_name);
2921         }
2922         ndr->depth--;
2923         ndr_print_ptr(ndr, "document_name", r->document_name);
2924         ndr->depth++;
2925         if (r->document_name) {
2926                 ndr_print_string(ndr, "document_name", r->document_name);
2927         }
2928         ndr->depth--;
2929         ndr_print_ptr(ndr, "data_type", r->data_type);
2930         ndr->depth++;
2931         if (r->data_type) {
2932                 ndr_print_string(ndr, "data_type", r->data_type);
2933         }
2934         ndr->depth--;
2935         ndr_print_ptr(ndr, "text_status", r->text_status);
2936         ndr->depth++;
2937         if (r->text_status) {
2938                 ndr_print_string(ndr, "text_status", r->text_status);
2939         }
2940         ndr->depth--;
2941         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2942         ndr_print_uint32(ndr, "priority", r->priority);
2943         ndr_print_uint32(ndr, "position", r->position);
2944         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2945         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2946         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2947         ndr->depth--;
2948 }
2949
2950 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2951 {
2952         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2953 }
2954
2955 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2956 {
2957         if (ndr_flags & NDR_SCALARS) {
2958                 NDR_CHECK(ndr_push_align(ndr, 4));
2959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2960                 {
2961                         uint32_t _flags_save_string = ndr->flags;
2962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2964                         ndr->flags = _flags_save_string;
2965                 }
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->server_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->user_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->document_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->notify_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->data_type));
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->print_processor));
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->parameters));
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->driver_name));
3012                         ndr->flags = _flags_save_string;
3013                 }
3014                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3015                 {
3016                         uint32_t _flags_save_string = ndr->flags;
3017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3018                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3019                         ndr->flags = _flags_save_string;
3020                 }
3021                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3022                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3029                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3032         }
3033         if (ndr_flags & NDR_BUFFERS) {
3034                 {
3035                         uint32_t _flags_save_string = ndr->flags;
3036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3037                         if (r->printer_name) {
3038                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3039                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3040                         }
3041                         ndr->flags = _flags_save_string;
3042                 }
3043                 {
3044                         uint32_t _flags_save_string = ndr->flags;
3045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3046                         if (r->server_name) {
3047                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3048                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3049                         }
3050                         ndr->flags = _flags_save_string;
3051                 }
3052                 {
3053                         uint32_t _flags_save_string = ndr->flags;
3054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3055                         if (r->user_name) {
3056                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3057                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3058                         }
3059                         ndr->flags = _flags_save_string;
3060                 }
3061                 {
3062                         uint32_t _flags_save_string = ndr->flags;
3063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3064                         if (r->document_name) {
3065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3067                         }
3068                         ndr->flags = _flags_save_string;
3069                 }
3070                 {
3071                         uint32_t _flags_save_string = ndr->flags;
3072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3073                         if (r->notify_name) {
3074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3076                         }
3077                         ndr->flags = _flags_save_string;
3078                 }
3079                 {
3080                         uint32_t _flags_save_string = ndr->flags;
3081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3082                         if (r->data_type) {
3083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3085                         }
3086                         ndr->flags = _flags_save_string;
3087                 }
3088                 {
3089                         uint32_t _flags_save_string = ndr->flags;
3090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3091                         if (r->print_processor) {
3092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3094                         }
3095                         ndr->flags = _flags_save_string;
3096                 }
3097                 {
3098                         uint32_t _flags_save_string = ndr->flags;
3099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3100                         if (r->parameters) {
3101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3103                         }
3104                         ndr->flags = _flags_save_string;
3105                 }
3106                 {
3107                         uint32_t _flags_save_string = ndr->flags;
3108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3109                         if (r->driver_name) {
3110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3112                         }
3113                         ndr->flags = _flags_save_string;
3114                 }
3115                 if (r->devmode) {
3116                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3117                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3118                 }
3119                 {
3120                         uint32_t _flags_save_string = ndr->flags;
3121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3122                         if (r->text_status) {
3123                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3124                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3125                         }
3126                         ndr->flags = _flags_save_string;
3127                 }
3128                 if (r->secdesc) {
3129                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3130                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3131                 }
3132         }
3133         return NDR_ERR_SUCCESS;
3134 }
3135
3136 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3137 {
3138         uint32_t _ptr_printer_name;
3139         TALLOC_CTX *_mem_save_printer_name_0;
3140         uint32_t _ptr_server_name;
3141         TALLOC_CTX *_mem_save_server_name_0;
3142         uint32_t _ptr_user_name;
3143         TALLOC_CTX *_mem_save_user_name_0;
3144         uint32_t _ptr_document_name;
3145         TALLOC_CTX *_mem_save_document_name_0;
3146         uint32_t _ptr_notify_name;
3147         TALLOC_CTX *_mem_save_notify_name_0;
3148         uint32_t _ptr_data_type;
3149         TALLOC_CTX *_mem_save_data_type_0;
3150         uint32_t _ptr_print_processor;
3151         TALLOC_CTX *_mem_save_print_processor_0;
3152         uint32_t _ptr_parameters;
3153         TALLOC_CTX *_mem_save_parameters_0;
3154         uint32_t _ptr_driver_name;
3155         TALLOC_CTX *_mem_save_driver_name_0;
3156         uint32_t _ptr_devmode;
3157         TALLOC_CTX *_mem_save_devmode_0;
3158         uint32_t _ptr_text_status;
3159         TALLOC_CTX *_mem_save_text_status_0;
3160         uint32_t _ptr_secdesc;
3161         TALLOC_CTX *_mem_save_secdesc_0;
3162         if (ndr_flags & NDR_SCALARS) {
3163                 NDR_CHECK(ndr_pull_align(ndr, 4));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3165                 {
3166                         uint32_t _flags_save_string = ndr->flags;
3167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3169                         if (_ptr_printer_name) {
3170                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3172                         } else {
3173                                 r->printer_name = NULL;
3174                         }
3175                         ndr->flags = _flags_save_string;
3176                 }
3177                 {
3178                         uint32_t _flags_save_string = ndr->flags;
3179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3181                         if (_ptr_server_name) {
3182                                 NDR_PULL_ALLOC(ndr, r->server_name);
3183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3184                         } else {
3185                                 r->server_name = NULL;
3186                         }
3187                         ndr->flags = _flags_save_string;
3188                 }
3189                 {
3190                         uint32_t _flags_save_string = ndr->flags;
3191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3193                         if (_ptr_user_name) {
3194                                 NDR_PULL_ALLOC(ndr, r->user_name);
3195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3196                         } else {
3197                                 r->user_name = NULL;
3198                         }
3199                         ndr->flags = _flags_save_string;
3200                 }
3201                 {
3202                         uint32_t _flags_save_string = ndr->flags;
3203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3205                         if (_ptr_document_name) {
3206                                 NDR_PULL_ALLOC(ndr, r->document_name);
3207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3208                         } else {
3209                                 r->document_name = NULL;
3210                         }
3211                         ndr->flags = _flags_save_string;
3212                 }
3213                 {
3214                         uint32_t _flags_save_string = ndr->flags;
3215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3217                         if (_ptr_notify_name) {
3218                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3220                         } else {
3221                                 r->notify_name = NULL;
3222                         }
3223                         ndr->flags = _flags_save_string;
3224                 }
3225                 {
3226                         uint32_t _flags_save_string = ndr->flags;
3227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3229                         if (_ptr_data_type) {
3230                                 NDR_PULL_ALLOC(ndr, r->data_type);
3231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3232                         } else {
3233                                 r->data_type = NULL;
3234                         }
3235                         ndr->flags = _flags_save_string;
3236                 }
3237                 {
3238                         uint32_t _flags_save_string = ndr->flags;
3239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3241                         if (_ptr_print_processor) {
3242                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3244                         } else {
3245                                 r->print_processor = NULL;
3246                         }
3247                         ndr->flags = _flags_save_string;
3248                 }
3249                 {
3250                         uint32_t _flags_save_string = ndr->flags;
3251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3253                         if (_ptr_parameters) {
3254                                 NDR_PULL_ALLOC(ndr, r->parameters);
3255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3256                         } else {
3257                                 r->parameters = NULL;
3258                         }
3259                         ndr->flags = _flags_save_string;
3260                 }
3261                 {
3262                         uint32_t _flags_save_string = ndr->flags;
3263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3264                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3265                         if (_ptr_driver_name) {
3266                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3267                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3268                         } else {
3269                                 r->driver_name = NULL;
3270                         }
3271                         ndr->flags = _flags_save_string;
3272                 }
3273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3274                 if (_ptr_devmode) {
3275                         NDR_PULL_ALLOC(ndr, r->devmode);
3276                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3277                 } else {
3278                         r->devmode = NULL;
3279                 }
3280                 {
3281                         uint32_t _flags_save_string = ndr->flags;
3282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3284                         if (_ptr_text_status) {
3285                                 NDR_PULL_ALLOC(ndr, r->text_status);
3286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3287                         } else {
3288                                 r->text_status = NULL;
3289                         }
3290                         ndr->flags = _flags_save_string;
3291                 }
3292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3293                 if (_ptr_secdesc) {
3294                         NDR_PULL_ALLOC(ndr, r->secdesc);
3295                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3296                 } else {
3297                         r->secdesc = NULL;
3298                 }
3299                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3306                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3309         }
3310         if (ndr_flags & NDR_BUFFERS) {
3311                 {
3312                         uint32_t _flags_save_string = ndr->flags;
3313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3314                         if (r->printer_name) {
3315                                 uint32_t _relative_save_offset;
3316                                 _relative_save_offset = ndr->offset;
3317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3318                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3322                                 ndr->offset = _relative_save_offset;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         if (r->server_name) {
3330                                 uint32_t _relative_save_offset;
3331                                 _relative_save_offset = ndr->offset;
3332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3333                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3334                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3337                                 ndr->offset = _relative_save_offset;
3338                         }
3339                         ndr->flags = _flags_save_string;
3340                 }
3341                 {
3342                         uint32_t _flags_save_string = ndr->flags;
3343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3344                         if (r->user_name) {
3345                                 uint32_t _relative_save_offset;
3346                                 _relative_save_offset = ndr->offset;
3347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3348                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3349                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3352                                 ndr->offset = _relative_save_offset;
3353                         }
3354                         ndr->flags = _flags_save_string;
3355                 }
3356                 {
3357                         uint32_t _flags_save_string = ndr->flags;
3358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3359                         if (r->document_name) {
3360                                 uint32_t _relative_save_offset;
3361                                 _relative_save_offset = ndr->offset;
3362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3363                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3364                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3367                                 ndr->offset = _relative_save_offset;
3368                         }
3369                         ndr->flags = _flags_save_string;
3370                 }
3371                 {
3372                         uint32_t _flags_save_string = ndr->flags;
3373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3374                         if (r->notify_name) {
3375                                 uint32_t _relative_save_offset;
3376                                 _relative_save_offset = ndr->offset;
3377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3378                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3379                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3382                                 ndr->offset = _relative_save_offset;
3383                         }
3384                         ndr->flags = _flags_save_string;
3385                 }
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->data_type) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3393                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3397                                 ndr->offset = _relative_save_offset;
3398                         }
3399                         ndr->flags = _flags_save_string;
3400                 }
3401                 {
3402                         uint32_t _flags_save_string = ndr->flags;
3403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3404                         if (r->print_processor) {
3405                                 uint32_t _relative_save_offset;
3406                                 _relative_save_offset = ndr->offset;
3407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3408                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3409                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3412                                 ndr->offset = _relative_save_offset;
3413                         }
3414                         ndr->flags = _flags_save_string;
3415                 }
3416                 {
3417                         uint32_t _flags_save_string = ndr->flags;
3418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3419                         if (r->parameters) {
3420                                 uint32_t _relative_save_offset;
3421                                 _relative_save_offset = ndr->offset;
3422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3423                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3424                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3427                                 ndr->offset = _relative_save_offset;
3428                         }
3429                         ndr->flags = _flags_save_string;
3430                 }
3431                 {
3432                         uint32_t _flags_save_string = ndr->flags;
3433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3434                         if (r->driver_name) {
3435                                 uint32_t _relative_save_offset;
3436                                 _relative_save_offset = ndr->offset;
3437                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3438                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3439                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3440                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3441                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3442                                 ndr->offset = _relative_save_offset;
3443                         }
3444                         ndr->flags = _flags_save_string;
3445                 }
3446                 if (r->devmode) {
3447                         uint32_t _relative_save_offset;
3448                         _relative_save_offset = ndr->offset;
3449                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3450                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3451                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3452                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3454                         ndr->offset = _relative_save_offset;
3455                 }
3456                 {
3457                         uint32_t _flags_save_string = ndr->flags;
3458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3459                         if (r->text_status) {
3460                                 uint32_t _relative_save_offset;
3461                                 _relative_save_offset = ndr->offset;
3462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3463                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3464                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3467                                 ndr->offset = _relative_save_offset;
3468                         }
3469                         ndr->flags = _flags_save_string;
3470                 }
3471                 if (r->secdesc) {
3472                         uint32_t _relative_save_offset;
3473                         _relative_save_offset = ndr->offset;
3474                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3475                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3476                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3477                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3479                         ndr->offset = _relative_save_offset;
3480                 }
3481         }
3482         return NDR_ERR_SUCCESS;
3483 }
3484
3485 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3486 {
3487         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3488         ndr->depth++;
3489         ndr_print_uint32(ndr, "job_id", r->job_id);
3490         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3491         ndr->depth++;
3492         if (r->printer_name) {
3493                 ndr_print_string(ndr, "printer_name", r->printer_name);
3494         }
3495         ndr->depth--;
3496         ndr_print_ptr(ndr, "server_name", r->server_name);
3497         ndr->depth++;
3498         if (r->server_name) {
3499                 ndr_print_string(ndr, "server_name", r->server_name);
3500         }
3501         ndr->depth--;
3502         ndr_print_ptr(ndr, "user_name", r->user_name);
3503         ndr->depth++;
3504         if (r->user_name) {
3505                 ndr_print_string(ndr, "user_name", r->user_name);
3506         }
3507         ndr->depth--;
3508         ndr_print_ptr(ndr, "document_name", r->document_name);
3509         ndr->depth++;
3510         if (r->document_name) {
3511                 ndr_print_string(ndr, "document_name", r->document_name);
3512         }
3513         ndr->depth--;
3514         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3515         ndr->depth++;
3516         if (r->notify_name) {
3517                 ndr_print_string(ndr, "notify_name", r->notify_name);
3518         }
3519         ndr->depth--;
3520         ndr_print_ptr(ndr, "data_type", r->data_type);
3521         ndr->depth++;
3522         if (r->data_type) {
3523                 ndr_print_string(ndr, "data_type", r->data_type);
3524         }
3525         ndr->depth--;
3526         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3527         ndr->depth++;
3528         if (r->print_processor) {
3529                 ndr_print_string(ndr, "print_processor", r->print_processor);
3530         }
3531         ndr->depth--;
3532         ndr_print_ptr(ndr, "parameters", r->parameters);
3533         ndr->depth++;
3534         if (r->parameters) {
3535                 ndr_print_string(ndr, "parameters", r->parameters);
3536         }
3537         ndr->depth--;
3538         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3539         ndr->depth++;
3540         if (r->driver_name) {
3541                 ndr_print_string(ndr, "driver_name", r->driver_name);
3542         }
3543         ndr->depth--;
3544         ndr_print_ptr(ndr, "devmode", r->devmode);
3545         ndr->depth++;
3546         if (r->devmode) {
3547                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3548         }
3549         ndr->depth--;
3550         ndr_print_ptr(ndr, "text_status", r->text_status);
3551         ndr->depth++;
3552         if (r->text_status) {
3553                 ndr_print_string(ndr, "text_status", r->text_status);
3554         }
3555         ndr->depth--;
3556         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3557         ndr->depth++;
3558         if (r->secdesc) {
3559                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3560         }
3561         ndr->depth--;
3562         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3563         ndr_print_uint32(ndr, "priority", r->priority);
3564         ndr_print_uint32(ndr, "position", r->position);
3565         ndr_print_uint32(ndr, "start_time", r->start_time);
3566         ndr_print_uint32(ndr, "until_time", r->until_time);
3567         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3568         ndr_print_uint32(ndr, "size", r->size);
3569         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3570         ndr_print_uint32(ndr, "time", r->time);
3571         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3572         ndr->depth--;
3573 }
3574
3575 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3576 {
3577         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3578 }
3579
3580 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3581 {
3582         if (ndr_flags & NDR_SCALARS) {
3583                 NDR_CHECK(ndr_push_align(ndr, 4));
3584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3587         }
3588         if (ndr_flags & NDR_BUFFERS) {
3589         }
3590         return NDR_ERR_SUCCESS;
3591 }
3592
3593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3594 {
3595         if (ndr_flags & NDR_SCALARS) {
3596                 NDR_CHECK(ndr_pull_align(ndr, 4));
3597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3600         }
3601         if (ndr_flags & NDR_BUFFERS) {
3602         }
3603         return NDR_ERR_SUCCESS;
3604 }
3605
3606 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3607 {
3608         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3609         ndr->depth++;
3610         ndr_print_uint32(ndr, "job_id", r->job_id);
3611         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3612         ndr_print_uint32(ndr, "reserved", r->reserved);
3613         ndr->depth--;
3614 }
3615
3616 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3617 {
3618         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3619 }
3620
3621 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3622 {
3623         if (ndr_flags & NDR_SCALARS) {
3624                 NDR_CHECK(ndr_push_align(ndr, 4));
3625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3626                 {
3627                         uint32_t _flags_save_string = ndr->flags;
3628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3630                         ndr->flags = _flags_save_string;
3631                 }
3632                 {
3633                         uint32_t _flags_save_string = ndr->flags;
3634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3635                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3636                         ndr->flags = _flags_save_string;
3637                 }
3638                 {
3639                         uint32_t _flags_save_string = ndr->flags;
3640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3641                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3642                         ndr->flags = _flags_save_string;
3643                 }
3644                 {
3645                         uint32_t _flags_save_string = ndr->flags;
3646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3647                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3648                         ndr->flags = _flags_save_string;
3649                 }
3650                 {
3651                         uint32_t _flags_save_string = ndr->flags;
3652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3653                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3654                         ndr->flags = _flags_save_string;
3655                 }
3656                 {
3657                         uint32_t _flags_save_string = ndr->flags;
3658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3659                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3660                         ndr->flags = _flags_save_string;
3661                 }
3662                 {
3663                         uint32_t _flags_save_string = ndr->flags;
3664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3665                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3666                         ndr->flags = _flags_save_string;
3667                 }
3668                 {
3669                         uint32_t _flags_save_string = ndr->flags;
3670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3671                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3672                         ndr->flags = _flags_save_string;
3673                 }
3674                 {
3675                         uint32_t _flags_save_string = ndr->flags;
3676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3677                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3678                         ndr->flags = _flags_save_string;
3679                 }
3680                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3681                 {
3682                         uint32_t _flags_save_string = ndr->flags;
3683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3684                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3685                         ndr->flags = _flags_save_string;
3686                 }
3687                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3688                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3695                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3699         }
3700         if (ndr_flags & NDR_BUFFERS) {
3701                 {
3702                         uint32_t _flags_save_string = ndr->flags;
3703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3704                         if (r->printer_name) {
3705                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3707                         }
3708                         ndr->flags = _flags_save_string;
3709                 }
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         if (r->server_name) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_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->user_name) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_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->document_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_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->notify_name) {
3741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_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->data_type) {
3750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
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->print_processor) {
3759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
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->parameters) {
3768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
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->driver_name) {
3777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3779                         }
3780                         ndr->flags = _flags_save_string;
3781                 }
3782                 if (r->devmode) {
3783                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3784                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3785                 }
3786                 {
3787                         uint32_t _flags_save_string = ndr->flags;
3788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3789                         if (r->text_status) {
3790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3792                         }
3793                         ndr->flags = _flags_save_string;
3794                 }
3795                 if (r->secdesc) {
3796                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3797                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3798                 }
3799         }
3800         return NDR_ERR_SUCCESS;
3801 }
3802
3803 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3804 {
3805         uint32_t _ptr_printer_name;
3806         TALLOC_CTX *_mem_save_printer_name_0;
3807         uint32_t _ptr_server_name;
3808         TALLOC_CTX *_mem_save_server_name_0;
3809         uint32_t _ptr_user_name;
3810         TALLOC_CTX *_mem_save_user_name_0;
3811         uint32_t _ptr_document_name;
3812         TALLOC_CTX *_mem_save_document_name_0;
3813         uint32_t _ptr_notify_name;
3814         TALLOC_CTX *_mem_save_notify_name_0;
3815         uint32_t _ptr_data_type;
3816         TALLOC_CTX *_mem_save_data_type_0;
3817         uint32_t _ptr_print_processor;
3818         TALLOC_CTX *_mem_save_print_processor_0;
3819         uint32_t _ptr_parameters;
3820         TALLOC_CTX *_mem_save_parameters_0;
3821         uint32_t _ptr_driver_name;
3822         TALLOC_CTX *_mem_save_driver_name_0;
3823         uint32_t _ptr_devmode;
3824         TALLOC_CTX *_mem_save_devmode_0;
3825         uint32_t _ptr_text_status;
3826         TALLOC_CTX *_mem_save_text_status_0;
3827         uint32_t _ptr_secdesc;
3828         TALLOC_CTX *_mem_save_secdesc_0;
3829         if (ndr_flags & NDR_SCALARS) {
3830                 NDR_CHECK(ndr_pull_align(ndr, 4));
3831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3832                 {
3833                         uint32_t _flags_save_string = ndr->flags;
3834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3835                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3836                         if (_ptr_printer_name) {
3837                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3838                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3839                         } else {
3840                                 r->printer_name = NULL;
3841                         }
3842                         ndr->flags = _flags_save_string;
3843                 }
3844                 {
3845                         uint32_t _flags_save_string = ndr->flags;
3846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3847                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3848                         if (_ptr_server_name) {
3849                                 NDR_PULL_ALLOC(ndr, r->server_name);
3850                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3851                         } else {
3852                                 r->server_name = NULL;
3853                         }
3854                         ndr->flags = _flags_save_string;
3855                 }
3856                 {
3857                         uint32_t _flags_save_string = ndr->flags;
3858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3859                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3860                         if (_ptr_user_name) {
3861                                 NDR_PULL_ALLOC(ndr, r->user_name);
3862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3863                         } else {
3864                                 r->user_name = NULL;
3865                         }
3866                         ndr->flags = _flags_save_string;
3867                 }
3868                 {
3869                         uint32_t _flags_save_string = ndr->flags;
3870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3871                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3872                         if (_ptr_document_name) {
3873                                 NDR_PULL_ALLOC(ndr, r->document_name);
3874                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3875                         } else {
3876                                 r->document_name = NULL;
3877                         }
3878                         ndr->flags = _flags_save_string;
3879                 }
3880                 {
3881                         uint32_t _flags_save_string = ndr->flags;
3882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3883                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3884                         if (_ptr_notify_name) {
3885                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3886                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3887                         } else {
3888                                 r->notify_name = NULL;
3889                         }
3890                         ndr->flags = _flags_save_string;
3891                 }
3892                 {
3893                         uint32_t _flags_save_string = ndr->flags;
3894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3895                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3896                         if (_ptr_data_type) {
3897                                 NDR_PULL_ALLOC(ndr, r->data_type);
3898                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3899                         } else {
3900                                 r->data_type = NULL;
3901                         }
3902                         ndr->flags = _flags_save_string;
3903                 }
3904                 {
3905                         uint32_t _flags_save_string = ndr->flags;
3906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3908                         if (_ptr_print_processor) {
3909                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3911                         } else {
3912                                 r->print_processor = NULL;
3913                         }
3914                         ndr->flags = _flags_save_string;
3915                 }
3916                 {
3917                         uint32_t _flags_save_string = ndr->flags;
3918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3920                         if (_ptr_parameters) {
3921                                 NDR_PULL_ALLOC(ndr, r->parameters);
3922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3923                         } else {
3924                                 r->parameters = NULL;
3925                         }
3926                         ndr->flags = _flags_save_string;
3927                 }
3928                 {
3929                         uint32_t _flags_save_string = ndr->flags;
3930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3931                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3932                         if (_ptr_driver_name) {
3933                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3934                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3935                         } else {
3936                                 r->driver_name = NULL;
3937                         }
3938                         ndr->flags = _flags_save_string;
3939                 }
3940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3941                 if (_ptr_devmode) {
3942                         NDR_PULL_ALLOC(ndr, r->devmode);
3943                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3944                 } else {
3945                         r->devmode = NULL;
3946                 }
3947                 {
3948                         uint32_t _flags_save_string = ndr->flags;
3949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3951                         if (_ptr_text_status) {
3952                                 NDR_PULL_ALLOC(ndr, r->text_status);
3953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3954                         } else {
3955                                 r->text_status = NULL;
3956                         }
3957                         ndr->flags = _flags_save_string;
3958                 }
3959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3960                 if (_ptr_secdesc) {
3961                         NDR_PULL_ALLOC(ndr, r->secdesc);
3962                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3963                 } else {
3964                         r->secdesc = NULL;
3965                 }
3966                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3973                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3977         }
3978         if (ndr_flags & NDR_BUFFERS) {
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->printer_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3986                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3990                                 ndr->offset = _relative_save_offset;
3991                         }
3992                         ndr->flags = _flags_save_string;
3993                 }
3994                 {
3995                         uint32_t _flags_save_string = ndr->flags;
3996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3997                         if (r->server_name) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4001                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4005                                 ndr->offset = _relative_save_offset;
4006                         }
4007                         ndr->flags = _flags_save_string;
4008                 }
4009                 {
4010                         uint32_t _flags_save_string = ndr->flags;
4011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4012                         if (r->user_name) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4016                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4020                                 ndr->offset = _relative_save_offset;
4021                         }
4022                         ndr->flags = _flags_save_string;
4023                 }
4024                 {
4025                         uint32_t _flags_save_string = ndr->flags;
4026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4027                         if (r->document_name) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4031                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4035                                 ndr->offset = _relative_save_offset;
4036                         }
4037                         ndr->flags = _flags_save_string;
4038                 }
4039                 {
4040                         uint32_t _flags_save_string = ndr->flags;
4041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4042                         if (r->notify_name) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4046                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4050                                 ndr->offset = _relative_save_offset;
4051                         }
4052                         ndr->flags = _flags_save_string;
4053                 }
4054                 {
4055                         uint32_t _flags_save_string = ndr->flags;
4056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4057                         if (r->data_type) {
4058                                 uint32_t _relative_save_offset;
4059                                 _relative_save_offset = ndr->offset;
4060                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4061                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4062                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4063                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4064                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4065                                 ndr->offset = _relative_save_offset;
4066                         }
4067                         ndr->flags = _flags_save_string;
4068                 }
4069                 {
4070                         uint32_t _flags_save_string = ndr->flags;
4071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4072                         if (r->print_processor) {
4073                                 uint32_t _relative_save_offset;
4074                                 _relative_save_offset = ndr->offset;
4075                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4076                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4077                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4078                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4079                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4080                                 ndr->offset = _relative_save_offset;
4081                         }
4082                         ndr->flags = _flags_save_string;
4083                 }
4084                 {
4085                         uint32_t _flags_save_string = ndr->flags;
4086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4087                         if (r->parameters) {
4088                                 uint32_t _relative_save_offset;
4089                                 _relative_save_offset = ndr->offset;
4090                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4091                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4092                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4093                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4094                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4095                                 ndr->offset = _relative_save_offset;
4096                         }
4097                         ndr->flags = _flags_save_string;
4098                 }
4099                 {
4100                         uint32_t _flags_save_string = ndr->flags;
4101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4102                         if (r->driver_name) {
4103                                 uint32_t _relative_save_offset;
4104                                 _relative_save_offset = ndr->offset;
4105                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4106                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4107                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4108                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4109                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4110                                 ndr->offset = _relative_save_offset;
4111                         }
4112                         ndr->flags = _flags_save_string;
4113                 }
4114                 if (r->devmode) {
4115                         uint32_t _relative_save_offset;
4116                         _relative_save_offset = ndr->offset;
4117                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4118                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4120                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4122                         ndr->offset = _relative_save_offset;
4123                 }
4124                 {
4125                         uint32_t _flags_save_string = ndr->flags;
4126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4127                         if (r->text_status) {
4128                                 uint32_t _relative_save_offset;
4129                                 _relative_save_offset = ndr->offset;
4130                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4131                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4132                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4133                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4134                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4135                                 ndr->offset = _relative_save_offset;
4136                         }
4137                         ndr->flags = _flags_save_string;
4138                 }
4139                 if (r->secdesc) {
4140                         uint32_t _relative_save_offset;
4141                         _relative_save_offset = ndr->offset;
4142                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4143                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4144                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4145                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4147                         ndr->offset = _relative_save_offset;
4148                 }
4149         }
4150         return NDR_ERR_SUCCESS;
4151 }
4152
4153 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4154 {
4155         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4156         ndr->depth++;
4157         ndr_print_uint32(ndr, "job_id", r->job_id);
4158         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4159         ndr->depth++;
4160         if (r->printer_name) {
4161                 ndr_print_string(ndr, "printer_name", r->printer_name);
4162         }
4163         ndr->depth--;
4164         ndr_print_ptr(ndr, "server_name", r->server_name);
4165         ndr->depth++;
4166         if (r->server_name) {
4167                 ndr_print_string(ndr, "server_name", r->server_name);
4168         }
4169         ndr->depth--;
4170         ndr_print_ptr(ndr, "user_name", r->user_name);
4171         ndr->depth++;
4172         if (r->user_name) {
4173                 ndr_print_string(ndr, "user_name", r->user_name);
4174         }
4175         ndr->depth--;
4176         ndr_print_ptr(ndr, "document_name", r->document_name);
4177         ndr->depth++;
4178         if (r->document_name) {
4179                 ndr_print_string(ndr, "document_name", r->document_name);
4180         }
4181         ndr->depth--;
4182         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4183         ndr->depth++;
4184         if (r->notify_name) {
4185                 ndr_print_string(ndr, "notify_name", r->notify_name);
4186         }
4187         ndr->depth--;
4188         ndr_print_ptr(ndr, "data_type", r->data_type);
4189         ndr->depth++;
4190         if (r->data_type) {
4191                 ndr_print_string(ndr, "data_type", r->data_type);
4192         }
4193         ndr->depth--;
4194         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4195         ndr->depth++;
4196         if (r->print_processor) {
4197                 ndr_print_string(ndr, "print_processor", r->print_processor);
4198         }
4199         ndr->depth--;
4200         ndr_print_ptr(ndr, "parameters", r->parameters);
4201         ndr->depth++;
4202         if (r->parameters) {
4203                 ndr_print_string(ndr, "parameters", r->parameters);
4204         }
4205         ndr->depth--;
4206         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4207         ndr->depth++;
4208         if (r->driver_name) {
4209                 ndr_print_string(ndr, "driver_name", r->driver_name);
4210         }
4211         ndr->depth--;
4212         ndr_print_ptr(ndr, "devmode", r->devmode);
4213         ndr->depth++;
4214         if (r->devmode) {
4215                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4216         }
4217         ndr->depth--;
4218         ndr_print_ptr(ndr, "text_status", r->text_status);
4219         ndr->depth++;
4220         if (r->text_status) {
4221                 ndr_print_string(ndr, "text_status", r->text_status);
4222         }
4223         ndr->depth--;
4224         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4225         ndr->depth++;
4226         if (r->secdesc) {
4227                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4228         }
4229         ndr->depth--;
4230         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4231         ndr_print_uint32(ndr, "priority", r->priority);
4232         ndr_print_uint32(ndr, "position", r->position);
4233         ndr_print_uint32(ndr, "start_time", r->start_time);
4234         ndr_print_uint32(ndr, "until_time", r->until_time);
4235         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4236         ndr_print_uint32(ndr, "size", r->size);
4237         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4238         ndr_print_uint32(ndr, "time", r->time);
4239         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4240         ndr_print_uint32(ndr, "size_high", r->size_high);
4241         ndr->depth--;
4242 }
4243
4244 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4245 {
4246         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4247 }
4248
4249 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4250 {
4251         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4252         if (ndr_flags & NDR_SCALARS) {
4253                 int level = ndr_push_get_switch_value(ndr, r);
4254                 switch (level) {
4255                         case 1: {
4256                                 NDR_CHECK(ndr_push_align(ndr, 4));
4257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4258                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4259                         break; }
4260
4261                         case 2: {
4262                                 NDR_CHECK(ndr_push_align(ndr, 4));
4263                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4264                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4265                         break; }
4266
4267                         case 3: {
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_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4271                         break; }
4272
4273                         case 4: {
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_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4277                         break; }
4278
4279                         default: {
4280                         break; }
4281
4282                 }
4283         }
4284         if (ndr_flags & NDR_BUFFERS) {
4285                 int level = ndr_push_get_switch_value(ndr, r);
4286                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4287                 switch (level) {
4288                         case 1:
4289                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4290                         break;
4291
4292                         case 2:
4293                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4294                         break;
4295
4296                         case 3:
4297                         break;
4298
4299                         case 4:
4300                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4301                         break;
4302
4303                         default:
4304                         break;
4305
4306                 }
4307         }
4308         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4309         return NDR_ERR_SUCCESS;
4310 }
4311
4312 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4313 {
4314         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4315         int level;
4316         level = ndr_pull_get_switch_value(ndr, r);
4317         if (ndr_flags & NDR_SCALARS) {
4318                 switch (level) {
4319                         case 1: {
4320                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4321                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4322                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4323                         break; }
4324
4325                         case 2: {
4326                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4327                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4328                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4329                         break; }
4330
4331                         case 3: {
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_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4335                         break; }
4336
4337                         case 4: {
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_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4341                         break; }
4342
4343                         default: {
4344                         break; }
4345
4346                 }
4347         }
4348         if (ndr_flags & NDR_BUFFERS) {
4349                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4350                 switch (level) {
4351                         case 1:
4352                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4353                         break;
4354
4355                         case 2:
4356                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4357                         break;
4358
4359                         case 3:
4360                         break;
4361
4362                         case 4:
4363                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4364                         break;
4365
4366                         default:
4367                         break;
4368
4369                 }
4370         }
4371         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4372         return NDR_ERR_SUCCESS;
4373 }
4374
4375 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4376 {
4377         int level;
4378         level = ndr_print_get_switch_value(ndr, r);
4379         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4380         switch (level) {
4381                 case 1:
4382                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4383                 break;
4384
4385                 case 2:
4386                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4387                 break;
4388
4389                 case 3:
4390                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4391                 break;
4392
4393                 case 4:
4394                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4395                 break;
4396
4397                 default:
4398                 break;
4399
4400         }
4401 }
4402
4403 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4404 {
4405         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4406 }
4407
4408 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4409 {
4410         if (ndr_flags & NDR_SCALARS) {
4411                 NDR_CHECK(ndr_push_align(ndr, 4));
4412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4419                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4424                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4425         }
4426         if (ndr_flags & NDR_BUFFERS) {
4427                 if (r->printer_name) {
4428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4432                 }
4433                 if (r->server_name) {
4434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4438                 }
4439                 if (r->user_name) {
4440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_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->user_name, CH_UTF16)));
4443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4444                 }
4445                 if (r->document_name) {
4446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_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->document_name, CH_UTF16)));
4449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4450                 }
4451                 if (r->data_type) {
4452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, 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->data_type, CH_UTF16)));
4455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4456                 }
4457                 if (r->text_status) {
4458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, 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->text_status, CH_UTF16)));
4461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4462                 }
4463         }
4464         return NDR_ERR_SUCCESS;
4465 }
4466
4467 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4468 {
4469         uint32_t _ptr_printer_name;
4470         TALLOC_CTX *_mem_save_printer_name_0;
4471         uint32_t _ptr_server_name;
4472         TALLOC_CTX *_mem_save_server_name_0;
4473         uint32_t _ptr_user_name;
4474         TALLOC_CTX *_mem_save_user_name_0;
4475         uint32_t _ptr_document_name;
4476         TALLOC_CTX *_mem_save_document_name_0;
4477         uint32_t _ptr_data_type;
4478         TALLOC_CTX *_mem_save_data_type_0;
4479         uint32_t _ptr_text_status;
4480         TALLOC_CTX *_mem_save_text_status_0;
4481         if (ndr_flags & NDR_SCALARS) {
4482                 NDR_CHECK(ndr_pull_align(ndr, 4));
4483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4485                 if (_ptr_printer_name) {
4486                         NDR_PULL_ALLOC(ndr, r->printer_name);
4487                 } else {
4488                         r->printer_name = NULL;
4489                 }
4490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4491                 if (_ptr_server_name) {
4492                         NDR_PULL_ALLOC(ndr, r->server_name);
4493                 } else {
4494                         r->server_name = NULL;
4495                 }
4496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4497                 if (_ptr_user_name) {
4498                         NDR_PULL_ALLOC(ndr, r->user_name);
4499                 } else {
4500                         r->user_name = NULL;
4501                 }
4502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4503                 if (_ptr_document_name) {
4504                         NDR_PULL_ALLOC(ndr, r->document_name);
4505                 } else {
4506                         r->document_name = NULL;
4507                 }
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4509                 if (_ptr_data_type) {
4510                         NDR_PULL_ALLOC(ndr, r->data_type);
4511                 } else {
4512                         r->data_type = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4515                 if (_ptr_text_status) {
4516                         NDR_PULL_ALLOC(ndr, r->text_status);
4517                 } else {
4518                         r->text_status = NULL;
4519                 }
4520                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4525                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4526         }
4527         if (ndr_flags & NDR_BUFFERS) {
4528                 if (r->printer_name) {
4529                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4530                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4533                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4534                                 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));
4535                         }
4536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4539                 }
4540                 if (r->server_name) {
4541                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4545                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4546                                 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));
4547                         }
4548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4551                 }
4552                 if (r->user_name) {
4553                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4554                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4557                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4558                                 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));
4559                         }
4560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4563                 }
4564                 if (r->document_name) {
4565                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4566                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4569                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4570                                 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));
4571                         }
4572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4575                 }
4576                 if (r->data_type) {
4577                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4578                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4581                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4582                                 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));
4583                         }
4584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4587                 }
4588                 if (r->text_status) {
4589                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4590                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4593                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4594                                 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));
4595                         }
4596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4599                 }
4600         }
4601         return NDR_ERR_SUCCESS;
4602 }
4603
4604 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4605 {
4606         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4607         ndr->depth++;
4608         ndr_print_uint32(ndr, "job_id", r->job_id);
4609         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4610         ndr->depth++;
4611         if (r->printer_name) {
4612                 ndr_print_string(ndr, "printer_name", r->printer_name);
4613         }
4614         ndr->depth--;
4615         ndr_print_ptr(ndr, "server_name", r->server_name);
4616         ndr->depth++;
4617         if (r->server_name) {
4618                 ndr_print_string(ndr, "server_name", r->server_name);
4619         }
4620         ndr->depth--;
4621         ndr_print_ptr(ndr, "user_name", r->user_name);
4622         ndr->depth++;
4623         if (r->user_name) {
4624                 ndr_print_string(ndr, "user_name", r->user_name);
4625         }
4626         ndr->depth--;
4627         ndr_print_ptr(ndr, "document_name", r->document_name);
4628         ndr->depth++;
4629         if (r->document_name) {
4630                 ndr_print_string(ndr, "document_name", r->document_name);
4631         }
4632         ndr->depth--;
4633         ndr_print_ptr(ndr, "data_type", r->data_type);
4634         ndr->depth++;
4635         if (r->data_type) {
4636                 ndr_print_string(ndr, "data_type", r->data_type);
4637         }
4638         ndr->depth--;
4639         ndr_print_ptr(ndr, "text_status", r->text_status);
4640         ndr->depth++;
4641         if (r->text_status) {
4642                 ndr_print_string(ndr, "text_status", r->text_status);
4643         }
4644         ndr->depth--;
4645         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4646         ndr_print_uint32(ndr, "priority", r->priority);
4647         ndr_print_uint32(ndr, "position", r->position);
4648         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4649         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4650         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4651         ndr->depth--;
4652 }
4653
4654 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4655 {
4656         if (ndr_flags & NDR_SCALARS) {
4657                 NDR_CHECK(ndr_push_align(ndr, 4));
4658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4671                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4678                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4681         }
4682         if (ndr_flags & NDR_BUFFERS) {
4683                 if (r->printer_name) {
4684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4687                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4688                 }
4689                 if (r->server_name) {
4690                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4693                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4694                 }
4695                 if (r->user_name) {
4696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4700                 }
4701                 if (r->document_name) {
4702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4705                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4706                 }
4707                 if (r->notify_name) {
4708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4711                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4712                 }
4713                 if (r->data_type) {
4714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4717                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4718                 }
4719                 if (r->print_processor) {
4720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4723                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4724                 }
4725                 if (r->parameters) {
4726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4730                 }
4731                 if (r->driver_name) {
4732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4736                 }
4737                 if (r->text_status) {
4738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4742                 }
4743         }
4744         return NDR_ERR_SUCCESS;
4745 }
4746
4747 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4748 {
4749         uint32_t _ptr_printer_name;
4750         TALLOC_CTX *_mem_save_printer_name_0;
4751         uint32_t _ptr_server_name;
4752         TALLOC_CTX *_mem_save_server_name_0;
4753         uint32_t _ptr_user_name;
4754         TALLOC_CTX *_mem_save_user_name_0;
4755         uint32_t _ptr_document_name;
4756         TALLOC_CTX *_mem_save_document_name_0;
4757         uint32_t _ptr_notify_name;
4758         TALLOC_CTX *_mem_save_notify_name_0;
4759         uint32_t _ptr_data_type;
4760         TALLOC_CTX *_mem_save_data_type_0;
4761         uint32_t _ptr_print_processor;
4762         TALLOC_CTX *_mem_save_print_processor_0;
4763         uint32_t _ptr_parameters;
4764         TALLOC_CTX *_mem_save_parameters_0;
4765         uint32_t _ptr_driver_name;
4766         TALLOC_CTX *_mem_save_driver_name_0;
4767         uint32_t _ptr_text_status;
4768         TALLOC_CTX *_mem_save_text_status_0;
4769         if (ndr_flags & NDR_SCALARS) {
4770                 NDR_CHECK(ndr_pull_align(ndr, 4));
4771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4773                 if (_ptr_printer_name) {
4774                         NDR_PULL_ALLOC(ndr, r->printer_name);
4775                 } else {
4776                         r->printer_name = NULL;
4777                 }
4778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4779                 if (_ptr_server_name) {
4780                         NDR_PULL_ALLOC(ndr, r->server_name);
4781                 } else {
4782                         r->server_name = NULL;
4783                 }
4784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4785                 if (_ptr_user_name) {
4786                         NDR_PULL_ALLOC(ndr, r->user_name);
4787                 } else {
4788                         r->user_name = NULL;
4789                 }
4790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4791                 if (_ptr_document_name) {
4792                         NDR_PULL_ALLOC(ndr, r->document_name);
4793                 } else {
4794                         r->document_name = NULL;
4795                 }
4796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4797                 if (_ptr_notify_name) {
4798                         NDR_PULL_ALLOC(ndr, r->notify_name);
4799                 } else {
4800                         r->notify_name = NULL;
4801                 }
4802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4803                 if (_ptr_data_type) {
4804                         NDR_PULL_ALLOC(ndr, r->data_type);
4805                 } else {
4806                         r->data_type = NULL;
4807                 }
4808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4809                 if (_ptr_print_processor) {
4810                         NDR_PULL_ALLOC(ndr, r->print_processor);
4811                 } else {
4812                         r->print_processor = NULL;
4813                 }
4814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4815                 if (_ptr_parameters) {
4816                         NDR_PULL_ALLOC(ndr, r->parameters);
4817                 } else {
4818                         r->parameters = NULL;
4819                 }
4820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4821                 if (_ptr_driver_name) {
4822                         NDR_PULL_ALLOC(ndr, r->driver_name);
4823                 } else {
4824                         r->driver_name = NULL;
4825                 }
4826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4828                 if (_ptr_text_status) {
4829                         NDR_PULL_ALLOC(ndr, r->text_status);
4830                 } else {
4831                         r->text_status = NULL;
4832                 }
4833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4834                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4841                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4844         }
4845         if (ndr_flags & NDR_BUFFERS) {
4846                 if (r->printer_name) {
4847                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4848                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4851                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4852                                 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));
4853                         }
4854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4857                 }
4858                 if (r->server_name) {
4859                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4860                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4863                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4864                                 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));
4865                         }
4866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4869                 }
4870                 if (r->user_name) {
4871                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4872                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4875                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4876                                 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));
4877                         }
4878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4881                 }
4882                 if (r->document_name) {
4883                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4884                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4887                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4888                                 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));
4889                         }
4890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4893                 }
4894                 if (r->notify_name) {
4895                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4896                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4899                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4900                                 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));
4901                         }
4902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4905                 }
4906                 if (r->data_type) {
4907                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4908                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4911                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4912                                 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));
4913                         }
4914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4917                 }
4918                 if (r->print_processor) {
4919                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4920                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4923                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4924                                 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));
4925                         }
4926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4929                 }
4930                 if (r->parameters) {
4931                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4932                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4935                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4936                                 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));
4937                         }
4938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4941                 }
4942                 if (r->driver_name) {
4943                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4944                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4947                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4948                                 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));
4949                         }
4950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4953                 }
4954                 if (r->text_status) {
4955                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4956                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4959                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4960                                 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));
4961                         }
4962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4965                 }
4966         }
4967         return NDR_ERR_SUCCESS;
4968 }
4969
4970 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4971 {
4972         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4973         ndr->depth++;
4974         ndr_print_uint32(ndr, "job_id", r->job_id);
4975         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4976         ndr->depth++;
4977         if (r->printer_name) {
4978                 ndr_print_string(ndr, "printer_name", r->printer_name);
4979         }
4980         ndr->depth--;
4981         ndr_print_ptr(ndr, "server_name", r->server_name);
4982         ndr->depth++;
4983         if (r->server_name) {
4984                 ndr_print_string(ndr, "server_name", r->server_name);
4985         }
4986         ndr->depth--;
4987         ndr_print_ptr(ndr, "user_name", r->user_name);
4988         ndr->depth++;
4989         if (r->user_name) {
4990                 ndr_print_string(ndr, "user_name", r->user_name);
4991         }
4992         ndr->depth--;
4993         ndr_print_ptr(ndr, "document_name", r->document_name);
4994         ndr->depth++;
4995         if (r->document_name) {
4996                 ndr_print_string(ndr, "document_name", r->document_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5000         ndr->depth++;
5001         if (r->notify_name) {
5002                 ndr_print_string(ndr, "notify_name", r->notify_name);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "data_type", r->data_type);
5006         ndr->depth++;
5007         if (r->data_type) {
5008                 ndr_print_string(ndr, "data_type", r->data_type);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5012         ndr->depth++;
5013         if (r->print_processor) {
5014                 ndr_print_string(ndr, "print_processor", r->print_processor);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "parameters", r->parameters);
5018         ndr->depth++;
5019         if (r->parameters) {
5020                 ndr_print_string(ndr, "parameters", r->parameters);
5021         }
5022         ndr->depth--;
5023         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5024         ndr->depth++;
5025         if (r->driver_name) {
5026                 ndr_print_string(ndr, "driver_name", r->driver_name);
5027         }
5028         ndr->depth--;
5029         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5030         ndr_print_ptr(ndr, "text_status", r->text_status);
5031         ndr->depth++;
5032         if (r->text_status) {
5033                 ndr_print_string(ndr, "text_status", r->text_status);
5034         }
5035         ndr->depth--;
5036         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5037         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5038         ndr_print_uint32(ndr, "priority", r->priority);
5039         ndr_print_uint32(ndr, "position", r->position);
5040         ndr_print_uint32(ndr, "start_time", r->start_time);
5041         ndr_print_uint32(ndr, "until_time", r->until_time);
5042         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5043         ndr_print_uint32(ndr, "size", r->size);
5044         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5045         ndr_print_uint32(ndr, "time", r->time);
5046         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5047         ndr->depth--;
5048 }
5049
5050 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5051 {
5052         if (ndr_flags & NDR_SCALARS) {
5053                 NDR_CHECK(ndr_push_align(ndr, 4));
5054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5067                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5074                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5078         }
5079         if (ndr_flags & NDR_BUFFERS) {
5080                 if (r->printer_name) {
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5085                 }
5086                 if (r->server_name) {
5087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5091                 }
5092                 if (r->user_name) {
5093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5097                 }
5098                 if (r->document_name) {
5099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_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->document_name, CH_UTF16)));
5102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5103                 }
5104                 if (r->notify_name) {
5105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_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->notify_name, CH_UTF16)));
5108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5109                 }
5110                 if (r->data_type) {
5111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, 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->data_type, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5115                 }
5116                 if (r->print_processor) {
5117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, 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->print_processor, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5121                 }
5122                 if (r->parameters) {
5123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, 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->parameters, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5127                 }
5128                 if (r->driver_name) {
5129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, 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->driver_name, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5133                 }
5134                 if (r->text_status) {
5135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, 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->text_status, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5139                 }
5140         }
5141         return NDR_ERR_SUCCESS;
5142 }
5143
5144 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5145 {
5146         uint32_t _ptr_printer_name;
5147         TALLOC_CTX *_mem_save_printer_name_0;
5148         uint32_t _ptr_server_name;
5149         TALLOC_CTX *_mem_save_server_name_0;
5150         uint32_t _ptr_user_name;
5151         TALLOC_CTX *_mem_save_user_name_0;
5152         uint32_t _ptr_document_name;
5153         TALLOC_CTX *_mem_save_document_name_0;
5154         uint32_t _ptr_notify_name;
5155         TALLOC_CTX *_mem_save_notify_name_0;
5156         uint32_t _ptr_data_type;
5157         TALLOC_CTX *_mem_save_data_type_0;
5158         uint32_t _ptr_print_processor;
5159         TALLOC_CTX *_mem_save_print_processor_0;
5160         uint32_t _ptr_parameters;
5161         TALLOC_CTX *_mem_save_parameters_0;
5162         uint32_t _ptr_driver_name;
5163         TALLOC_CTX *_mem_save_driver_name_0;
5164         uint32_t _ptr_text_status;
5165         TALLOC_CTX *_mem_save_text_status_0;
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 4));
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5170                 if (_ptr_printer_name) {
5171                         NDR_PULL_ALLOC(ndr, r->printer_name);
5172                 } else {
5173                         r->printer_name = NULL;
5174                 }
5175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5176                 if (_ptr_server_name) {
5177                         NDR_PULL_ALLOC(ndr, r->server_name);
5178                 } else {
5179                         r->server_name = NULL;
5180                 }
5181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5182                 if (_ptr_user_name) {
5183                         NDR_PULL_ALLOC(ndr, r->user_name);
5184                 } else {
5185                         r->user_name = NULL;
5186                 }
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5188                 if (_ptr_document_name) {
5189                         NDR_PULL_ALLOC(ndr, r->document_name);
5190                 } else {
5191                         r->document_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5194                 if (_ptr_notify_name) {
5195                         NDR_PULL_ALLOC(ndr, r->notify_name);
5196                 } else {
5197                         r->notify_name = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5200                 if (_ptr_data_type) {
5201                         NDR_PULL_ALLOC(ndr, r->data_type);
5202                 } else {
5203                         r->data_type = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5206                 if (_ptr_print_processor) {
5207                         NDR_PULL_ALLOC(ndr, r->print_processor);
5208                 } else {
5209                         r->print_processor = NULL;
5210                 }
5211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5212                 if (_ptr_parameters) {
5213                         NDR_PULL_ALLOC(ndr, r->parameters);
5214                 } else {
5215                         r->parameters = NULL;
5216                 }
5217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5218                 if (_ptr_driver_name) {
5219                         NDR_PULL_ALLOC(ndr, r->driver_name);
5220                 } else {
5221                         r->driver_name = NULL;
5222                 }
5223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5225                 if (_ptr_text_status) {
5226                         NDR_PULL_ALLOC(ndr, r->text_status);
5227                 } else {
5228                         r->text_status = NULL;
5229                 }
5230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5231                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5238                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5242         }
5243         if (ndr_flags & NDR_BUFFERS) {
5244                 if (r->printer_name) {
5245                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5246                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5248                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5249                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5250                                 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));
5251                         }
5252                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5253                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5255                 }
5256                 if (r->server_name) {
5257                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5258                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5259                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5260                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5261                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5262                                 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));
5263                         }
5264                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5265                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5267                 }
5268                 if (r->user_name) {
5269                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5270                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5271                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5272                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5273                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5274                                 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));
5275                         }
5276                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5277                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5279                 }
5280                 if (r->document_name) {
5281                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5282                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5283                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5284                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5285                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5286                                 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));
5287                         }
5288                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5289                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5291                 }
5292                 if (r->notify_name) {
5293                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5294                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5296                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5297                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5298                                 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));
5299                         }
5300                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5303                 }
5304                 if (r->data_type) {
5305                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5306                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5307                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5308                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5309                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5310                                 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));
5311                         }
5312                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5313                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5314                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5315                 }
5316                 if (r->print_processor) {
5317                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5318                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5320                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5321                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5322                                 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));
5323                         }
5324                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5325                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5327                 }
5328                 if (r->parameters) {
5329                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5330                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5331                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5332                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5333                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5334                                 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));
5335                         }
5336                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5339                 }
5340                 if (r->driver_name) {
5341                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5342                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5344                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5345                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5346                                 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));
5347                         }
5348                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5349                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5351                 }
5352                 if (r->text_status) {
5353                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5354                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5357                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5358                                 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));
5359                         }
5360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5361                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5363                 }
5364         }
5365         return NDR_ERR_SUCCESS;
5366 }
5367
5368 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5369 {
5370         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5371         ndr->depth++;
5372         ndr_print_uint32(ndr, "job_id", r->job_id);
5373         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5374         ndr->depth++;
5375         if (r->printer_name) {
5376                 ndr_print_string(ndr, "printer_name", r->printer_name);
5377         }
5378         ndr->depth--;
5379         ndr_print_ptr(ndr, "server_name", r->server_name);
5380         ndr->depth++;
5381         if (r->server_name) {
5382                 ndr_print_string(ndr, "server_name", r->server_name);
5383         }
5384         ndr->depth--;
5385         ndr_print_ptr(ndr, "user_name", r->user_name);
5386         ndr->depth++;
5387         if (r->user_name) {
5388                 ndr_print_string(ndr, "user_name", r->user_name);
5389         }
5390         ndr->depth--;
5391         ndr_print_ptr(ndr, "document_name", r->document_name);
5392         ndr->depth++;
5393         if (r->document_name) {
5394                 ndr_print_string(ndr, "document_name", r->document_name);
5395         }
5396         ndr->depth--;
5397         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5398         ndr->depth++;
5399         if (r->notify_name) {
5400                 ndr_print_string(ndr, "notify_name", r->notify_name);
5401         }
5402         ndr->depth--;
5403         ndr_print_ptr(ndr, "data_type", r->data_type);
5404         ndr->depth++;
5405         if (r->data_type) {
5406                 ndr_print_string(ndr, "data_type", r->data_type);
5407         }
5408         ndr->depth--;
5409         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5410         ndr->depth++;
5411         if (r->print_processor) {
5412                 ndr_print_string(ndr, "print_processor", r->print_processor);
5413         }
5414         ndr->depth--;
5415         ndr_print_ptr(ndr, "parameters", r->parameters);
5416         ndr->depth++;
5417         if (r->parameters) {
5418                 ndr_print_string(ndr, "parameters", r->parameters);
5419         }
5420         ndr->depth--;
5421         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5422         ndr->depth++;
5423         if (r->driver_name) {
5424                 ndr_print_string(ndr, "driver_name", r->driver_name);
5425         }
5426         ndr->depth--;
5427         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5428         ndr_print_ptr(ndr, "text_status", r->text_status);
5429         ndr->depth++;
5430         if (r->text_status) {
5431                 ndr_print_string(ndr, "text_status", r->text_status);
5432         }
5433         ndr->depth--;
5434         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5435         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5436         ndr_print_uint32(ndr, "priority", r->priority);
5437         ndr_print_uint32(ndr, "position", r->position);
5438         ndr_print_uint32(ndr, "start_time", r->start_time);
5439         ndr_print_uint32(ndr, "until_time", r->until_time);
5440         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5441         ndr_print_uint32(ndr, "size", r->size);
5442         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5443         ndr_print_uint32(ndr, "time", r->time);
5444         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5445         ndr_print_uint32(ndr, "size_high", r->size_high);
5446         ndr->depth--;
5447 }
5448
5449 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5450 {
5451         if (ndr_flags & NDR_SCALARS) {
5452                 int level = ndr_push_get_switch_value(ndr, r);
5453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5454                 switch (level) {
5455                         case 1: {
5456                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5457                         break; }
5458
5459                         case 2: {
5460                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5461                         break; }
5462
5463                         case 3: {
5464                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5465                         break; }
5466
5467                         case 4: {
5468                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5469                         break; }
5470
5471                         default: {
5472                         break; }
5473
5474                 }
5475         }
5476         if (ndr_flags & NDR_BUFFERS) {
5477                 int level = ndr_push_get_switch_value(ndr, r);
5478                 switch (level) {
5479                         case 1:
5480                                 if (r->info1) {
5481                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5482                                 }
5483                         break;
5484
5485                         case 2:
5486                                 if (r->info2) {
5487                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5488                                 }
5489                         break;
5490
5491                         case 3:
5492                                 if (r->info3) {
5493                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5494                                 }
5495                         break;
5496
5497                         case 4:
5498                                 if (r->info4) {
5499                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5500                                 }
5501                         break;
5502
5503                         default:
5504                         break;
5505
5506                 }
5507         }
5508         return NDR_ERR_SUCCESS;
5509 }
5510
5511 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5512 {
5513         int level;
5514         uint32_t _level;
5515         TALLOC_CTX *_mem_save_info1_0;
5516         TALLOC_CTX *_mem_save_info2_0;
5517         TALLOC_CTX *_mem_save_info3_0;
5518         TALLOC_CTX *_mem_save_info4_0;
5519         level = ndr_pull_get_switch_value(ndr, r);
5520         if (ndr_flags & NDR_SCALARS) {
5521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5522                 if (_level != level) {
5523                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5524                 }
5525                 switch (level) {
5526                         case 1: {
5527                                 uint32_t _ptr_info1;
5528                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5529                                 if (_ptr_info1) {
5530                                         NDR_PULL_ALLOC(ndr, r->info1);
5531                                 } else {
5532                                         r->info1 = NULL;
5533                                 }
5534                         break; }
5535
5536                         case 2: {
5537                                 uint32_t _ptr_info2;
5538                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5539                                 if (_ptr_info2) {
5540                                         NDR_PULL_ALLOC(ndr, r->info2);
5541                                 } else {
5542                                         r->info2 = NULL;
5543                                 }
5544                         break; }
5545
5546                         case 3: {
5547                                 uint32_t _ptr_info3;
5548                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5549                                 if (_ptr_info3) {
5550                                         NDR_PULL_ALLOC(ndr, r->info3);
5551                                 } else {
5552                                         r->info3 = NULL;
5553                                 }
5554                         break; }
5555
5556                         case 4: {
5557                                 uint32_t _ptr_info4;
5558                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5559                                 if (_ptr_info4) {
5560                                         NDR_PULL_ALLOC(ndr, r->info4);
5561                                 } else {
5562                                         r->info4 = NULL;
5563                                 }
5564                         break; }
5565
5566                         default: {
5567                         break; }
5568
5569                 }
5570         }
5571         if (ndr_flags & NDR_BUFFERS) {
5572                 switch (level) {
5573                         case 1:
5574                                 if (r->info1) {
5575                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5576                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5577                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5578                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5579                                 }
5580                         break;
5581
5582                         case 2:
5583                                 if (r->info2) {
5584                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5585                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5586                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5587                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5588                                 }
5589                         break;
5590
5591                         case 3:
5592                                 if (r->info3) {
5593                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5594                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5595                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5596                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5597                                 }
5598                         break;
5599
5600                         case 4:
5601                                 if (r->info4) {
5602                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5603                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5604                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5605                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5606                                 }
5607                         break;
5608
5609                         default:
5610                         break;
5611
5612                 }
5613         }
5614         return NDR_ERR_SUCCESS;
5615 }
5616
5617 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5618 {
5619         int level;
5620         level = ndr_print_get_switch_value(ndr, r);
5621         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5622         switch (level) {
5623                 case 1:
5624                         ndr_print_ptr(ndr, "info1", r->info1);
5625                         ndr->depth++;
5626                         if (r->info1) {
5627                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5628                         }
5629                         ndr->depth--;
5630                 break;
5631
5632                 case 2:
5633                         ndr_print_ptr(ndr, "info2", r->info2);
5634                         ndr->depth++;
5635                         if (r->info2) {
5636                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5637                         }
5638                         ndr->depth--;
5639                 break;
5640
5641                 case 3:
5642                         ndr_print_ptr(ndr, "info3", r->info3);
5643                         ndr->depth++;
5644                         if (r->info3) {
5645                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5646                         }
5647                         ndr->depth--;
5648                 break;
5649
5650                 case 4:
5651                         ndr_print_ptr(ndr, "info4", r->info4);
5652                         ndr->depth++;
5653                         if (r->info4) {
5654                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5655                         }
5656                         ndr->depth--;
5657                 break;
5658
5659                 default:
5660                 break;
5661
5662         }
5663 }
5664
5665 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5666 {
5667         if (ndr_flags & NDR_SCALARS) {
5668                 NDR_CHECK(ndr_push_align(ndr, 4));
5669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5670                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5671                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5672         }
5673         if (ndr_flags & NDR_BUFFERS) {
5674                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5675         }
5676         return NDR_ERR_SUCCESS;
5677 }
5678
5679 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5680 {
5681         if (ndr_flags & NDR_SCALARS) {
5682                 NDR_CHECK(ndr_pull_align(ndr, 4));
5683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5684                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5685                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5686         }
5687         if (ndr_flags & NDR_BUFFERS) {
5688                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5689         }
5690         return NDR_ERR_SUCCESS;
5691 }
5692
5693 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5694 {
5695         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5696         ndr->depth++;
5697         ndr_print_uint32(ndr, "level", r->level);
5698         ndr_print_set_switch_value(ndr, &r->info, r->level);
5699         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5700         ndr->depth--;
5701 }
5702
5703 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5704 {
5705         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5706         return NDR_ERR_SUCCESS;
5707 }
5708
5709 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5710 {
5711         uint32_t v;
5712         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5713         *r = v;
5714         return NDR_ERR_SUCCESS;
5715 }
5716
5717 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5718 {
5719         const char *val = NULL;
5720
5721         switch (r) {
5722                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5723                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5724                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5725                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5726                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5727                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5728                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5729                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5730                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5731         }
5732         ndr_print_enum(ndr, name, "ENUM", val, r);
5733 }
5734
5735 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5736 {
5737         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5738         return NDR_ERR_SUCCESS;
5739 }
5740
5741 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5742 {
5743         uint32_t v;
5744         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5745         *r = v;
5746         return NDR_ERR_SUCCESS;
5747 }
5748
5749 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5750 {
5751         const char *val = NULL;
5752
5753         switch (r) {
5754                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5755                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5756                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5757                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5758                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5759         }
5760         ndr_print_enum(ndr, name, "ENUM", val, r);
5761 }
5762
5763 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5764 {
5765         if (ndr_flags & NDR_SCALARS) {
5766                 NDR_CHECK(ndr_push_align(ndr, 4));
5767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5772                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5784                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5791                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5792                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5796         }
5797         if (ndr_flags & NDR_BUFFERS) {
5798                 if (r->servername) {
5799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5802                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5803                 }
5804                 if (r->printername) {
5805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5808                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5809                 }
5810         }
5811         return NDR_ERR_SUCCESS;
5812 }
5813
5814 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5815 {
5816         uint32_t _ptr_servername;
5817         TALLOC_CTX *_mem_save_servername_0;
5818         uint32_t _ptr_printername;
5819         TALLOC_CTX *_mem_save_printername_0;
5820         if (ndr_flags & NDR_SCALARS) {
5821                 NDR_CHECK(ndr_pull_align(ndr, 4));
5822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5823                 if (_ptr_servername) {
5824                         NDR_PULL_ALLOC(ndr, r->servername);
5825                 } else {
5826                         r->servername = NULL;
5827                 }
5828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5829                 if (_ptr_printername) {
5830                         NDR_PULL_ALLOC(ndr, r->printername);
5831                 } else {
5832                         r->printername = NULL;
5833                 }
5834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5837                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5849                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5852                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5856                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5857                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5861         }
5862         if (ndr_flags & NDR_BUFFERS) {
5863                 if (r->servername) {
5864                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5865                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5868                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5869                                 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));
5870                         }
5871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5874                 }
5875                 if (r->printername) {
5876                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5877                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5878                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5879                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5880                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5881                                 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));
5882                         }
5883                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5884                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5886                 }
5887         }
5888         return NDR_ERR_SUCCESS;
5889 }
5890
5891 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5892 {
5893         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5894         ndr->depth++;
5895         ndr_print_ptr(ndr, "servername", r->servername);
5896         ndr->depth++;
5897         if (r->servername) {
5898                 ndr_print_string(ndr, "servername", r->servername);
5899         }
5900         ndr->depth--;
5901         ndr_print_ptr(ndr, "printername", r->printername);
5902         ndr->depth++;
5903         if (r->printername) {
5904                 ndr_print_string(ndr, "printername", r->printername);
5905         }
5906         ndr->depth--;
5907         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5908         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5909         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5910         ndr_print_spoolss_Time(ndr, "time", &r->time);
5911         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5912         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5913         ndr_print_uint32(ndr, "version", r->version);
5914         ndr_print_uint32(ndr, "free_build", r->free_build);
5915         ndr_print_uint32(ndr, "spooling", r->spooling);
5916         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5917         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5918         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5919         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5920         ndr_print_uint32(ndr, "job_error", r->job_error);
5921         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5922         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5923         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5924         ndr_print_uint32(ndr, "change_id", r->change_id);
5925         ndr_print_WERROR(ndr, "last_error", r->last_error);
5926         ndr_print_uint32(ndr, "status", r->status);
5927         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5928         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5929         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5930         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5931         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5932         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5933         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5934         ndr->depth--;
5935 }
5936
5937 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5938 {
5939         if (ndr_flags & NDR_SCALARS) {
5940                 NDR_CHECK(ndr_push_align(ndr, 4));
5941                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5945         }
5946         if (ndr_flags & NDR_BUFFERS) {
5947                 if (r->name) {
5948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5952                 }
5953                 if (r->description) {
5954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5958                 }
5959                 if (r->comment) {
5960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5964                 }
5965         }
5966         return NDR_ERR_SUCCESS;
5967 }
5968
5969 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5970 {
5971         uint32_t _ptr_name;
5972         TALLOC_CTX *_mem_save_name_0;
5973         uint32_t _ptr_description;
5974         TALLOC_CTX *_mem_save_description_0;
5975         uint32_t _ptr_comment;
5976         TALLOC_CTX *_mem_save_comment_0;
5977         if (ndr_flags & NDR_SCALARS) {
5978                 NDR_CHECK(ndr_pull_align(ndr, 4));
5979                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
5980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
5981                 if (_ptr_name) {
5982                         NDR_PULL_ALLOC(ndr, r->name);
5983                 } else {
5984                         r->name = NULL;
5985                 }
5986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
5987                 if (_ptr_description) {
5988                         NDR_PULL_ALLOC(ndr, r->description);
5989                 } else {
5990                         r->description = NULL;
5991                 }
5992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5993                 if (_ptr_comment) {
5994                         NDR_PULL_ALLOC(ndr, r->comment);
5995                 } else {
5996                         r->comment = NULL;
5997                 }
5998         }
5999         if (ndr_flags & NDR_BUFFERS) {
6000                 if (r->name) {
6001                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6002                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6003                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6004                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6005                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6006                                 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));
6007                         }
6008                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6009                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6011                 }
6012                 if (r->description) {
6013                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6014                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6015                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6016                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6017                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6018                                 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));
6019                         }
6020                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6021                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6023                 }
6024                 if (r->comment) {
6025                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6026                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6027                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6028                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6029                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6030                                 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));
6031                         }
6032                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6033                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6035                 }
6036         }
6037         return NDR_ERR_SUCCESS;
6038 }
6039
6040 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6041 {
6042         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6043         ndr->depth++;
6044         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6045         ndr_print_ptr(ndr, "name", r->name);
6046         ndr->depth++;
6047         if (r->name) {
6048                 ndr_print_string(ndr, "name", r->name);
6049         }
6050         ndr->depth--;
6051         ndr_print_ptr(ndr, "description", r->description);
6052         ndr->depth++;
6053         if (r->description) {
6054                 ndr_print_string(ndr, "description", r->description);
6055         }
6056         ndr->depth--;
6057         ndr_print_ptr(ndr, "comment", r->comment);
6058         ndr->depth++;
6059         if (r->comment) {
6060                 ndr_print_string(ndr, "comment", r->comment);
6061         }
6062         ndr->depth--;
6063         ndr->depth--;
6064 }
6065
6066 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6067 {
6068         if (ndr_flags & NDR_SCALARS) {
6069                 NDR_CHECK(ndr_push_align(ndr, 4));
6070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6083                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6088                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6091         }
6092         if (ndr_flags & NDR_BUFFERS) {
6093                 if (r->servername) {
6094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6097                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6098                 }
6099                 if (r->printername) {
6100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6104                 }
6105                 if (r->sharename) {
6106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6109                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6110                 }
6111                 if (r->portname) {
6112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6115                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6116                 }
6117                 if (r->drivername) {
6118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6121                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6122                 }
6123                 if (r->comment) {
6124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6127                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6128                 }
6129                 if (r->location) {
6130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6132                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6133                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6134                 }
6135                 if (r->devmode) {
6136                         {
6137                                 struct ndr_push *_ndr_devmode;
6138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6139                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6141                         }
6142                 }
6143                 if (r->sepfile) {
6144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6148                 }
6149                 if (r->printprocessor) {
6150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6153                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6154                 }
6155                 if (r->datatype) {
6156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6157                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6158                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6159                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6160                 }
6161                 if (r->parameters) {
6162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6163                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6164                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6166                 }
6167                 if (r->secdesc) {
6168                         {
6169                                 struct ndr_push *_ndr_secdesc;
6170                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6171                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6172                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6173                         }
6174                 }
6175         }
6176         return NDR_ERR_SUCCESS;
6177 }
6178
6179 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6180 {
6181         uint32_t _ptr_servername;
6182         TALLOC_CTX *_mem_save_servername_0;
6183         uint32_t _ptr_printername;
6184         TALLOC_CTX *_mem_save_printername_0;
6185         uint32_t _ptr_sharename;
6186         TALLOC_CTX *_mem_save_sharename_0;
6187         uint32_t _ptr_portname;
6188         TALLOC_CTX *_mem_save_portname_0;
6189         uint32_t _ptr_drivername;
6190         TALLOC_CTX *_mem_save_drivername_0;
6191         uint32_t _ptr_comment;
6192         TALLOC_CTX *_mem_save_comment_0;
6193         uint32_t _ptr_location;
6194         TALLOC_CTX *_mem_save_location_0;
6195         uint32_t _ptr_devmode;
6196         TALLOC_CTX *_mem_save_devmode_0;
6197         uint32_t _ptr_sepfile;
6198         TALLOC_CTX *_mem_save_sepfile_0;
6199         uint32_t _ptr_printprocessor;
6200         TALLOC_CTX *_mem_save_printprocessor_0;
6201         uint32_t _ptr_datatype;
6202         TALLOC_CTX *_mem_save_datatype_0;
6203         uint32_t _ptr_parameters;
6204         TALLOC_CTX *_mem_save_parameters_0;
6205         uint32_t _ptr_secdesc;
6206         TALLOC_CTX *_mem_save_secdesc_0;
6207         if (ndr_flags & NDR_SCALARS) {
6208                 NDR_CHECK(ndr_pull_align(ndr, 4));
6209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6210                 if (_ptr_servername) {
6211                         NDR_PULL_ALLOC(ndr, r->servername);
6212                 } else {
6213                         r->servername = NULL;
6214                 }
6215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6216                 if (_ptr_printername) {
6217                         NDR_PULL_ALLOC(ndr, r->printername);
6218                 } else {
6219                         r->printername = NULL;
6220                 }
6221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6222                 if (_ptr_sharename) {
6223                         NDR_PULL_ALLOC(ndr, r->sharename);
6224                 } else {
6225                         r->sharename = NULL;
6226                 }
6227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6228                 if (_ptr_portname) {
6229                         NDR_PULL_ALLOC(ndr, r->portname);
6230                 } else {
6231                         r->portname = NULL;
6232                 }
6233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6234                 if (_ptr_drivername) {
6235                         NDR_PULL_ALLOC(ndr, r->drivername);
6236                 } else {
6237                         r->drivername = NULL;
6238                 }
6239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6240                 if (_ptr_comment) {
6241                         NDR_PULL_ALLOC(ndr, r->comment);
6242                 } else {
6243                         r->comment = NULL;
6244                 }
6245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6246                 if (_ptr_location) {
6247                         NDR_PULL_ALLOC(ndr, r->location);
6248                 } else {
6249                         r->location = NULL;
6250                 }
6251                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6252                 if (_ptr_devmode) {
6253                         NDR_PULL_ALLOC(ndr, r->devmode);
6254                 } else {
6255                         r->devmode = NULL;
6256                 }
6257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6258                 if (_ptr_sepfile) {
6259                         NDR_PULL_ALLOC(ndr, r->sepfile);
6260                 } else {
6261                         r->sepfile = NULL;
6262                 }
6263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6264                 if (_ptr_printprocessor) {
6265                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6266                 } else {
6267                         r->printprocessor = NULL;
6268                 }
6269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6270                 if (_ptr_datatype) {
6271                         NDR_PULL_ALLOC(ndr, r->datatype);
6272                 } else {
6273                         r->datatype = NULL;
6274                 }
6275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6276                 if (_ptr_parameters) {
6277                         NDR_PULL_ALLOC(ndr, r->parameters);
6278                 } else {
6279                         r->parameters = NULL;
6280                 }
6281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6282                 if (_ptr_secdesc) {
6283                         NDR_PULL_ALLOC(ndr, r->secdesc);
6284                 } else {
6285                         r->secdesc = NULL;
6286                 }
6287                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6292                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6295         }
6296         if (ndr_flags & NDR_BUFFERS) {
6297                 if (r->servername) {
6298                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6299                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6300                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6301                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6302                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6303                                 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));
6304                         }
6305                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6306                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6308                 }
6309                 if (r->printername) {
6310                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6311                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6312                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6313                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6314                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6315                                 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));
6316                         }
6317                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6318                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6320                 }
6321                 if (r->sharename) {
6322                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6323                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6326                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
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->sharename), ndr_get_array_length(ndr, &r->sharename));
6328                         }
6329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6332                 }
6333                 if (r->portname) {
6334                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6335                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6338                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
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->portname), ndr_get_array_length(ndr, &r->portname));
6340                         }
6341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6344                 }
6345                 if (r->drivername) {
6346                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6347                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6350                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
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->drivername), ndr_get_array_length(ndr, &r->drivername));
6352                         }
6353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6356                 }
6357                 if (r->comment) {
6358                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6359                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6362                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
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->comment), ndr_get_array_length(ndr, &r->comment));
6364                         }
6365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6368                 }
6369                 if (r->location) {
6370                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6374                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
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->location), ndr_get_array_length(ndr, &r->location));
6376                         }
6377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6380                 }
6381                 if (r->devmode) {
6382                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6384                         {
6385                                 struct ndr_pull *_ndr_devmode;
6386                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6387                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6388                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6389                         }
6390                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6391                 }
6392                 if (r->sepfile) {
6393                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6394                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6396                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6397                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6398                                 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));
6399                         }
6400                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6401                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6403                 }
6404                 if (r->printprocessor) {
6405                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6406                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6408                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6409                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6410                                 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));
6411                         }
6412                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6413                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6415                 }
6416                 if (r->datatype) {
6417                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6418                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6421                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
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->datatype), ndr_get_array_length(ndr, &r->datatype));
6423                         }
6424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6425                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6427                 }
6428                 if (r->parameters) {
6429                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6430                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6433                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
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->parameters), ndr_get_array_length(ndr, &r->parameters));
6435                         }
6436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6439                 }
6440                 if (r->secdesc) {
6441                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6443                         {
6444                                 struct ndr_pull *_ndr_secdesc;
6445                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6446                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6447                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6448                         }
6449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6450                 }
6451         }
6452         return NDR_ERR_SUCCESS;
6453 }
6454
6455 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6456 {
6457         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6458         ndr->depth++;
6459         ndr_print_ptr(ndr, "servername", r->servername);
6460         ndr->depth++;
6461         if (r->servername) {
6462                 ndr_print_string(ndr, "servername", r->servername);
6463         }
6464         ndr->depth--;
6465         ndr_print_ptr(ndr, "printername", r->printername);
6466         ndr->depth++;
6467         if (r->printername) {
6468                 ndr_print_string(ndr, "printername", r->printername);
6469         }
6470         ndr->depth--;
6471         ndr_print_ptr(ndr, "sharename", r->sharename);
6472         ndr->depth++;
6473         if (r->sharename) {
6474                 ndr_print_string(ndr, "sharename", r->sharename);
6475         }
6476         ndr->depth--;
6477         ndr_print_ptr(ndr, "portname", r->portname);
6478         ndr->depth++;
6479         if (r->portname) {
6480                 ndr_print_string(ndr, "portname", r->portname);
6481         }
6482         ndr->depth--;
6483         ndr_print_ptr(ndr, "drivername", r->drivername);
6484         ndr->depth++;
6485         if (r->drivername) {
6486                 ndr_print_string(ndr, "drivername", r->drivername);
6487         }
6488         ndr->depth--;
6489         ndr_print_ptr(ndr, "comment", r->comment);
6490         ndr->depth++;
6491         if (r->comment) {
6492                 ndr_print_string(ndr, "comment", r->comment);
6493         }
6494         ndr->depth--;
6495         ndr_print_ptr(ndr, "location", r->location);
6496         ndr->depth++;
6497         if (r->location) {
6498                 ndr_print_string(ndr, "location", r->location);
6499         }
6500         ndr->depth--;
6501         ndr_print_ptr(ndr, "devmode", r->devmode);
6502         ndr->depth++;
6503         if (r->devmode) {
6504                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6505         }
6506         ndr->depth--;
6507         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6508         ndr->depth++;
6509         if (r->sepfile) {
6510                 ndr_print_string(ndr, "sepfile", r->sepfile);
6511         }
6512         ndr->depth--;
6513         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6514         ndr->depth++;
6515         if (r->printprocessor) {
6516                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6517         }
6518         ndr->depth--;
6519         ndr_print_ptr(ndr, "datatype", r->datatype);
6520         ndr->depth++;
6521         if (r->datatype) {
6522                 ndr_print_string(ndr, "datatype", r->datatype);
6523         }
6524         ndr->depth--;
6525         ndr_print_ptr(ndr, "parameters", r->parameters);
6526         ndr->depth++;
6527         if (r->parameters) {
6528                 ndr_print_string(ndr, "parameters", r->parameters);
6529         }
6530         ndr->depth--;
6531         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6532         ndr->depth++;
6533         if (r->secdesc) {
6534                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6535         }
6536         ndr->depth--;
6537         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6538         ndr_print_uint32(ndr, "priority", r->priority);
6539         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6540         ndr_print_uint32(ndr, "starttime", r->starttime);
6541         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6542         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6543         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6544         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6545         ndr->depth--;
6546 }
6547
6548 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6549 {
6550         if (ndr_flags & NDR_SCALARS) {
6551                 NDR_CHECK(ndr_push_align(ndr, 4));
6552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6553         }
6554         if (ndr_flags & NDR_BUFFERS) {
6555         }
6556         return NDR_ERR_SUCCESS;
6557 }
6558
6559 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6560 {
6561         if (ndr_flags & NDR_SCALARS) {
6562                 NDR_CHECK(ndr_pull_align(ndr, 4));
6563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6564         }
6565         if (ndr_flags & NDR_BUFFERS) {
6566         }
6567         return NDR_ERR_SUCCESS;
6568 }
6569
6570 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6571 {
6572         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6573         ndr->depth++;
6574         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6575         ndr->depth--;
6576 }
6577
6578 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6579 {
6580         if (ndr_flags & NDR_SCALARS) {
6581                 NDR_CHECK(ndr_push_align(ndr, 4));
6582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6583                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6584                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6585         }
6586         if (ndr_flags & NDR_BUFFERS) {
6587                 if (r->printername) {
6588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6592                 }
6593                 if (r->servername) {
6594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6597                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6598                 }
6599         }
6600         return NDR_ERR_SUCCESS;
6601 }
6602
6603 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6604 {
6605         uint32_t _ptr_printername;
6606         TALLOC_CTX *_mem_save_printername_0;
6607         uint32_t _ptr_servername;
6608         TALLOC_CTX *_mem_save_servername_0;
6609         if (ndr_flags & NDR_SCALARS) {
6610                 NDR_CHECK(ndr_pull_align(ndr, 4));
6611                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6612                 if (_ptr_printername) {
6613                         NDR_PULL_ALLOC(ndr, r->printername);
6614                 } else {
6615                         r->printername = NULL;
6616                 }
6617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6618                 if (_ptr_servername) {
6619                         NDR_PULL_ALLOC(ndr, r->servername);
6620                 } else {
6621                         r->servername = NULL;
6622                 }
6623                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6624         }
6625         if (ndr_flags & NDR_BUFFERS) {
6626                 if (r->printername) {
6627                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6628                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6629                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6630                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6631                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6632                                 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));
6633                         }
6634                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6635                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6637                 }
6638                 if (r->servername) {
6639                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6640                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6641                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6642                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6643                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6644                                 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));
6645                         }
6646                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6647                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6648                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6649                 }
6650         }
6651         return NDR_ERR_SUCCESS;
6652 }
6653
6654 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6655 {
6656         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6657         ndr->depth++;
6658         ndr_print_ptr(ndr, "printername", r->printername);
6659         ndr->depth++;
6660         if (r->printername) {
6661                 ndr_print_string(ndr, "printername", r->printername);
6662         }
6663         ndr->depth--;
6664         ndr_print_ptr(ndr, "servername", r->servername);
6665         ndr->depth++;
6666         if (r->servername) {
6667                 ndr_print_string(ndr, "servername", r->servername);
6668         }
6669         ndr->depth--;
6670         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6671         ndr->depth--;
6672 }
6673
6674 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6675 {
6676         if (ndr_flags & NDR_SCALARS) {
6677                 NDR_CHECK(ndr_push_align(ndr, 4));
6678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6680                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6683         }
6684         if (ndr_flags & NDR_BUFFERS) {
6685                 if (r->printername) {
6686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6689                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6690                 }
6691                 if (r->portname) {
6692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6696                 }
6697         }
6698         return NDR_ERR_SUCCESS;
6699 }
6700
6701 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6702 {
6703         uint32_t _ptr_printername;
6704         TALLOC_CTX *_mem_save_printername_0;
6705         uint32_t _ptr_portname;
6706         TALLOC_CTX *_mem_save_portname_0;
6707         if (ndr_flags & NDR_SCALARS) {
6708                 NDR_CHECK(ndr_pull_align(ndr, 4));
6709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6710                 if (_ptr_printername) {
6711                         NDR_PULL_ALLOC(ndr, r->printername);
6712                 } else {
6713                         r->printername = NULL;
6714                 }
6715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6716                 if (_ptr_portname) {
6717                         NDR_PULL_ALLOC(ndr, r->portname);
6718                 } else {
6719                         r->portname = NULL;
6720                 }
6721                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6724         }
6725         if (ndr_flags & NDR_BUFFERS) {
6726                 if (r->printername) {
6727                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6728                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6729                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6730                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6731                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6732                                 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));
6733                         }
6734                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6735                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6737                 }
6738                 if (r->portname) {
6739                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6740                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6743                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6744                                 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));
6745                         }
6746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6749                 }
6750         }
6751         return NDR_ERR_SUCCESS;
6752 }
6753
6754 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6755 {
6756         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6757         ndr->depth++;
6758         ndr_print_ptr(ndr, "printername", r->printername);
6759         ndr->depth++;
6760         if (r->printername) {
6761                 ndr_print_string(ndr, "printername", r->printername);
6762         }
6763         ndr->depth--;
6764         ndr_print_ptr(ndr, "portname", r->portname);
6765         ndr->depth++;
6766         if (r->portname) {
6767                 ndr_print_string(ndr, "portname", r->portname);
6768         }
6769         ndr->depth--;
6770         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6771         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6772         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6773         ndr->depth--;
6774 }
6775
6776 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6777 {
6778         if (ndr_flags & NDR_SCALARS) {
6779                 NDR_CHECK(ndr_push_align(ndr, 4));
6780                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6781         }
6782         if (ndr_flags & NDR_BUFFERS) {
6783         }
6784         return NDR_ERR_SUCCESS;
6785 }
6786
6787 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6788 {
6789         if (ndr_flags & NDR_SCALARS) {
6790                 NDR_CHECK(ndr_pull_align(ndr, 4));
6791                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6792         }
6793         if (ndr_flags & NDR_BUFFERS) {
6794         }
6795         return NDR_ERR_SUCCESS;
6796 }
6797
6798 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6799 {
6800         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6801         ndr->depth++;
6802         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6803         ndr->depth--;
6804 }
6805
6806 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6807 {
6808         if (ndr_flags & NDR_SCALARS) {
6809                 NDR_CHECK(ndr_push_align(ndr, 4));
6810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6811                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6812         }
6813         if (ndr_flags & NDR_BUFFERS) {
6814                 if (r->guid) {
6815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6819                 }
6820         }
6821         return NDR_ERR_SUCCESS;
6822 }
6823
6824 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6825 {
6826         uint32_t _ptr_guid;
6827         TALLOC_CTX *_mem_save_guid_0;
6828         if (ndr_flags & NDR_SCALARS) {
6829                 NDR_CHECK(ndr_pull_align(ndr, 4));
6830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6831                 if (_ptr_guid) {
6832                         NDR_PULL_ALLOC(ndr, r->guid);
6833                 } else {
6834                         r->guid = NULL;
6835                 }
6836                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6837         }
6838         if (ndr_flags & NDR_BUFFERS) {
6839                 if (r->guid) {
6840                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6841                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6842                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6843                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6844                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6845                                 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));
6846                         }
6847                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6848                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6850                 }
6851         }
6852         return NDR_ERR_SUCCESS;
6853 }
6854
6855 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6856 {
6857         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6858         ndr->depth++;
6859         ndr_print_ptr(ndr, "guid", r->guid);
6860         ndr->depth++;
6861         if (r->guid) {
6862                 ndr_print_string(ndr, "guid", r->guid);
6863         }
6864         ndr->depth--;
6865         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6866         ndr->depth--;
6867 }
6868
6869 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6870 {
6871         if (ndr_flags & NDR_SCALARS) {
6872                 int level = ndr_push_get_switch_value(ndr, r);
6873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6874                 switch (level) {
6875                         case 0: {
6876                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6877                         break; }
6878
6879                         case 1: {
6880                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6881                         break; }
6882
6883                         case 2: {
6884                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6885                         break; }
6886
6887                         case 3: {
6888                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6889                         break; }
6890
6891                         case 4: {
6892                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6893                         break; }
6894
6895                         case 5: {
6896                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6897                         break; }
6898
6899                         case 6: {
6900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6901                         break; }
6902
6903                         case 7: {
6904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6905                         break; }
6906
6907                         case 8: {
6908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6909                         break; }
6910
6911                         case 9: {
6912                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6913                         break; }
6914
6915                         default: {
6916                         break; }
6917
6918                 }
6919         }
6920         if (ndr_flags & NDR_BUFFERS) {
6921                 int level = ndr_push_get_switch_value(ndr, r);
6922                 switch (level) {
6923                         case 0:
6924                                 if (r->info0) {
6925                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6926                                 }
6927                         break;
6928
6929                         case 1:
6930                                 if (r->info1) {
6931                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6932                                 }
6933                         break;
6934
6935                         case 2:
6936                                 if (r->info2) {
6937                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6938                                 }
6939                         break;
6940
6941                         case 3:
6942                                 if (r->info3) {
6943                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6944                                 }
6945                         break;
6946
6947                         case 4:
6948                                 if (r->info4) {
6949                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6950                                 }
6951                         break;
6952
6953                         case 5:
6954                                 if (r->info5) {
6955                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6956                                 }
6957                         break;
6958
6959                         case 6:
6960                                 if (r->info6) {
6961                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6962                                 }
6963                         break;
6964
6965                         case 7:
6966                                 if (r->info7) {
6967                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6968                                 }
6969                         break;
6970
6971                         case 8:
6972                                 if (r->info8) {
6973                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6974                                 }
6975                         break;
6976
6977                         case 9:
6978                                 if (r->info9) {
6979                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
6980                                 }
6981                         break;
6982
6983                         default:
6984                         break;
6985
6986                 }
6987         }
6988         return NDR_ERR_SUCCESS;
6989 }
6990
6991 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
6992 {
6993         int level;
6994         uint32_t _level;
6995         TALLOC_CTX *_mem_save_info0_0;
6996         TALLOC_CTX *_mem_save_info1_0;
6997         TALLOC_CTX *_mem_save_info2_0;
6998         TALLOC_CTX *_mem_save_info3_0;
6999         TALLOC_CTX *_mem_save_info4_0;
7000         TALLOC_CTX *_mem_save_info5_0;
7001         TALLOC_CTX *_mem_save_info6_0;
7002         TALLOC_CTX *_mem_save_info7_0;
7003         TALLOC_CTX *_mem_save_info8_0;
7004         TALLOC_CTX *_mem_save_info9_0;
7005         level = ndr_pull_get_switch_value(ndr, r);
7006         if (ndr_flags & NDR_SCALARS) {
7007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7008                 if (_level != level) {
7009                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7010                 }
7011                 switch (level) {
7012                         case 0: {
7013                                 uint32_t _ptr_info0;
7014                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7015                                 if (_ptr_info0) {
7016                                         NDR_PULL_ALLOC(ndr, r->info0);
7017                                 } else {
7018                                         r->info0 = NULL;
7019                                 }
7020                         break; }
7021
7022                         case 1: {
7023                                 uint32_t _ptr_info1;
7024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7025                                 if (_ptr_info1) {
7026                                         NDR_PULL_ALLOC(ndr, r->info1);
7027                                 } else {
7028                                         r->info1 = NULL;
7029                                 }
7030                         break; }
7031
7032                         case 2: {
7033                                 uint32_t _ptr_info2;
7034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7035                                 if (_ptr_info2) {
7036                                         NDR_PULL_ALLOC(ndr, r->info2);
7037                                 } else {
7038                                         r->info2 = NULL;
7039                                 }
7040                         break; }
7041
7042                         case 3: {
7043                                 uint32_t _ptr_info3;
7044                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7045                                 if (_ptr_info3) {
7046                                         NDR_PULL_ALLOC(ndr, r->info3);
7047                                 } else {
7048                                         r->info3 = NULL;
7049                                 }
7050                         break; }
7051
7052                         case 4: {
7053                                 uint32_t _ptr_info4;
7054                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7055                                 if (_ptr_info4) {
7056                                         NDR_PULL_ALLOC(ndr, r->info4);
7057                                 } else {
7058                                         r->info4 = NULL;
7059                                 }
7060                         break; }
7061
7062                         case 5: {
7063                                 uint32_t _ptr_info5;
7064                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7065                                 if (_ptr_info5) {
7066                                         NDR_PULL_ALLOC(ndr, r->info5);
7067                                 } else {
7068                                         r->info5 = NULL;
7069                                 }
7070                         break; }
7071
7072                         case 6: {
7073                                 uint32_t _ptr_info6;
7074                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7075                                 if (_ptr_info6) {
7076                                         NDR_PULL_ALLOC(ndr, r->info6);
7077                                 } else {
7078                                         r->info6 = NULL;
7079                                 }
7080                         break; }
7081
7082                         case 7: {
7083                                 uint32_t _ptr_info7;
7084                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7085                                 if (_ptr_info7) {
7086                                         NDR_PULL_ALLOC(ndr, r->info7);
7087                                 } else {
7088                                         r->info7 = NULL;
7089                                 }
7090                         break; }
7091
7092                         case 8: {
7093                                 uint32_t _ptr_info8;
7094                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7095                                 if (_ptr_info8) {
7096                                         NDR_PULL_ALLOC(ndr, r->info8);
7097                                 } else {
7098                                         r->info8 = NULL;
7099                                 }
7100                         break; }
7101
7102                         case 9: {
7103                                 uint32_t _ptr_info9;
7104                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7105                                 if (_ptr_info9) {
7106                                         NDR_PULL_ALLOC(ndr, r->info9);
7107                                 } else {
7108                                         r->info9 = NULL;
7109                                 }
7110                         break; }
7111
7112                         default: {
7113                         break; }
7114
7115                 }
7116         }
7117         if (ndr_flags & NDR_BUFFERS) {
7118                 switch (level) {
7119                         case 0:
7120                                 if (r->info0) {
7121                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7122                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7123                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7124                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7125                                 }
7126                         break;
7127
7128                         case 1:
7129                                 if (r->info1) {
7130                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7131                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7132                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7133                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7134                                 }
7135                         break;
7136
7137                         case 2:
7138                                 if (r->info2) {
7139                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7140                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7141                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7142                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7143                                 }
7144                         break;
7145
7146                         case 3:
7147                                 if (r->info3) {
7148                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7149                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7150                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7151                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7152                                 }
7153                         break;
7154
7155                         case 4:
7156                                 if (r->info4) {
7157                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7158                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7159                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7160                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7161                                 }
7162                         break;
7163
7164                         case 5:
7165                                 if (r->info5) {
7166                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7167                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7168                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7169                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7170                                 }
7171                         break;
7172
7173                         case 6:
7174                                 if (r->info6) {
7175                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7176                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7177                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7178                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7179                                 }
7180                         break;
7181
7182                         case 7:
7183                                 if (r->info7) {
7184                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7185                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7186                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7187                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7188                                 }
7189                         break;
7190
7191                         case 8:
7192                                 if (r->info8) {
7193                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7194                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7195                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7196                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7197                                 }
7198                         break;
7199
7200                         case 9:
7201                                 if (r->info9) {
7202                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7203                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7204                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7205                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7206                                 }
7207                         break;
7208
7209                         default:
7210                         break;
7211
7212                 }
7213         }
7214         return NDR_ERR_SUCCESS;
7215 }
7216
7217 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7218 {
7219         int level;
7220         level = ndr_print_get_switch_value(ndr, r);
7221         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7222         switch (level) {
7223                 case 0:
7224                         ndr_print_ptr(ndr, "info0", r->info0);
7225                         ndr->depth++;
7226                         if (r->info0) {
7227                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7228                         }
7229                         ndr->depth--;
7230                 break;
7231
7232                 case 1:
7233                         ndr_print_ptr(ndr, "info1", r->info1);
7234                         ndr->depth++;
7235                         if (r->info1) {
7236                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7237                         }
7238                         ndr->depth--;
7239                 break;
7240
7241                 case 2:
7242                         ndr_print_ptr(ndr, "info2", r->info2);
7243                         ndr->depth++;
7244                         if (r->info2) {
7245                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7246                         }
7247                         ndr->depth--;
7248                 break;
7249
7250                 case 3:
7251                         ndr_print_ptr(ndr, "info3", r->info3);
7252                         ndr->depth++;
7253                         if (r->info3) {
7254                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7255                         }
7256                         ndr->depth--;
7257                 break;
7258
7259                 case 4:
7260                         ndr_print_ptr(ndr, "info4", r->info4);
7261                         ndr->depth++;
7262                         if (r->info4) {
7263                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7264                         }
7265                         ndr->depth--;
7266                 break;
7267
7268                 case 5:
7269                         ndr_print_ptr(ndr, "info5", r->info5);
7270                         ndr->depth++;
7271                         if (r->info5) {
7272                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7273                         }
7274                         ndr->depth--;
7275                 break;
7276
7277                 case 6:
7278                         ndr_print_ptr(ndr, "info6", r->info6);
7279                         ndr->depth++;
7280                         if (r->info6) {
7281                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7282                         }
7283                         ndr->depth--;
7284                 break;
7285
7286                 case 7:
7287                         ndr_print_ptr(ndr, "info7", r->info7);
7288                         ndr->depth++;
7289                         if (r->info7) {
7290                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7291                         }
7292                         ndr->depth--;
7293                 break;
7294
7295                 case 8:
7296                         ndr_print_ptr(ndr, "info8", r->info8);
7297                         ndr->depth++;
7298                         if (r->info8) {
7299                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7300                         }
7301                         ndr->depth--;
7302                 break;
7303
7304                 case 9:
7305                         ndr_print_ptr(ndr, "info9", r->info9);
7306                         ndr->depth++;
7307                         if (r->info9) {
7308                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7309                         }
7310                         ndr->depth--;
7311                 break;
7312
7313                 default:
7314                 break;
7315
7316         }
7317 }
7318
7319 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7320 {
7321         if (ndr_flags & NDR_SCALARS) {
7322                 NDR_CHECK(ndr_push_align(ndr, 4));
7323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7324                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7325                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7326         }
7327         if (ndr_flags & NDR_BUFFERS) {
7328                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7329         }
7330         return NDR_ERR_SUCCESS;
7331 }
7332
7333 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7334 {
7335         if (ndr_flags & NDR_SCALARS) {
7336                 NDR_CHECK(ndr_pull_align(ndr, 4));
7337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7338                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7339                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7343         }
7344         return NDR_ERR_SUCCESS;
7345 }
7346
7347 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7348 {
7349         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7350         ndr->depth++;
7351         ndr_print_uint32(ndr, "level", r->level);
7352         ndr_print_set_switch_value(ndr, &r->info, r->level);
7353         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7354         ndr->depth--;
7355 }
7356
7357 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7358 {
7359         if (ndr_flags & NDR_SCALARS) {
7360                 NDR_CHECK(ndr_push_align(ndr, 4));
7361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7362                 {
7363                         uint32_t _flags_save_string_array = ndr->flags;
7364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7365                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7366                         ndr->flags = _flags_save_string_array;
7367                 }
7368         }
7369         if (ndr_flags & NDR_BUFFERS) {
7370         }
7371         return NDR_ERR_SUCCESS;
7372 }
7373
7374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7375 {
7376         if (ndr_flags & NDR_SCALARS) {
7377                 NDR_CHECK(ndr_pull_align(ndr, 4));
7378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7379                 {
7380                         uint32_t _flags_save_string_array = ndr->flags;
7381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7382                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7383                         ndr->flags = _flags_save_string_array;
7384                 }
7385         }
7386         if (ndr_flags & NDR_BUFFERS) {
7387         }
7388         return NDR_ERR_SUCCESS;
7389 }
7390
7391 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7392 {
7393         ndr_print_struct(ndr, name, "spoolss_StringArray");
7394         ndr->depth++;
7395         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);
7396         ndr_print_string_array(ndr, "string", r->string);
7397         ndr->depth--;
7398 }
7399
7400 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7401 {
7402         if (ndr_flags & NDR_SCALARS) {
7403                 NDR_CHECK(ndr_push_align(ndr, 4));
7404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7405         }
7406         if (ndr_flags & NDR_BUFFERS) {
7407                 if (r->driver_name) {
7408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7411                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7412                 }
7413         }
7414         return NDR_ERR_SUCCESS;
7415 }
7416
7417 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7418 {
7419         uint32_t _ptr_driver_name;
7420         TALLOC_CTX *_mem_save_driver_name_0;
7421         if (ndr_flags & NDR_SCALARS) {
7422                 NDR_CHECK(ndr_pull_align(ndr, 4));
7423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7424                 if (_ptr_driver_name) {
7425                         NDR_PULL_ALLOC(ndr, r->driver_name);
7426                 } else {
7427                         r->driver_name = NULL;
7428                 }
7429         }
7430         if (ndr_flags & NDR_BUFFERS) {
7431                 if (r->driver_name) {
7432                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7433                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7434                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7435                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7436                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7437                                 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));
7438                         }
7439                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7440                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7442                 }
7443         }
7444         return NDR_ERR_SUCCESS;
7445 }
7446
7447 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7448 {
7449         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7450         ndr->depth++;
7451         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7452         ndr->depth++;
7453         if (r->driver_name) {
7454                 ndr_print_string(ndr, "driver_name", r->driver_name);
7455         }
7456         ndr->depth--;
7457         ndr->depth--;
7458 }
7459
7460 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7461 {
7462         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7463         return NDR_ERR_SUCCESS;
7464 }
7465
7466 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7467 {
7468         uint32_t v;
7469         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7470         *r = v;
7471         return NDR_ERR_SUCCESS;
7472 }
7473
7474 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7475 {
7476         const char *val = NULL;
7477
7478         switch (r) {
7479                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7480                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7481                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7482                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7483         }
7484         ndr_print_enum(ndr, name, "ENUM", val, r);
7485 }
7486
7487 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7488 {
7489         if (ndr_flags & NDR_SCALARS) {
7490                 NDR_CHECK(ndr_push_align(ndr, 4));
7491                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7497         }
7498         if (ndr_flags & NDR_BUFFERS) {
7499                 if (r->driver_name) {
7500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7503                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7504                 }
7505                 if (r->architecture) {
7506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7507                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7508                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7509                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7510                 }
7511                 if (r->driver_path) {
7512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7515                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7516                 }
7517                 if (r->data_file) {
7518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7521                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7522                 }
7523                 if (r->config_file) {
7524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, 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->config_file, CH_UTF16)));
7527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7528                 }
7529         }
7530         return NDR_ERR_SUCCESS;
7531 }
7532
7533 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7534 {
7535         uint32_t _ptr_driver_name;
7536         TALLOC_CTX *_mem_save_driver_name_0;
7537         uint32_t _ptr_architecture;
7538         TALLOC_CTX *_mem_save_architecture_0;
7539         uint32_t _ptr_driver_path;
7540         TALLOC_CTX *_mem_save_driver_path_0;
7541         uint32_t _ptr_data_file;
7542         TALLOC_CTX *_mem_save_data_file_0;
7543         uint32_t _ptr_config_file;
7544         TALLOC_CTX *_mem_save_config_file_0;
7545         if (ndr_flags & NDR_SCALARS) {
7546                 NDR_CHECK(ndr_pull_align(ndr, 4));
7547                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7549                 if (_ptr_driver_name) {
7550                         NDR_PULL_ALLOC(ndr, r->driver_name);
7551                 } else {
7552                         r->driver_name = NULL;
7553                 }
7554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7555                 if (_ptr_architecture) {
7556                         NDR_PULL_ALLOC(ndr, r->architecture);
7557                 } else {
7558                         r->architecture = NULL;
7559                 }
7560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7561                 if (_ptr_driver_path) {
7562                         NDR_PULL_ALLOC(ndr, r->driver_path);
7563                 } else {
7564                         r->driver_path = NULL;
7565                 }
7566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7567                 if (_ptr_data_file) {
7568                         NDR_PULL_ALLOC(ndr, r->data_file);
7569                 } else {
7570                         r->data_file = NULL;
7571                 }
7572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7573                 if (_ptr_config_file) {
7574                         NDR_PULL_ALLOC(ndr, r->config_file);
7575                 } else {
7576                         r->config_file = NULL;
7577                 }
7578         }
7579         if (ndr_flags & NDR_BUFFERS) {
7580                 if (r->driver_name) {
7581                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7582                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7585                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7586                                 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));
7587                         }
7588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7591                 }
7592                 if (r->architecture) {
7593                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7594                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7597                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7598                                 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));
7599                         }
7600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7603                 }
7604                 if (r->driver_path) {
7605                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7606                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7609                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
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_path), ndr_get_array_length(ndr, &r->driver_path));
7611                         }
7612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7615                 }
7616                 if (r->data_file) {
7617                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7618                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7621                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
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->data_file), ndr_get_array_length(ndr, &r->data_file));
7623                         }
7624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7627                 }
7628                 if (r->config_file) {
7629                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7630                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7633                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
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->config_file), ndr_get_array_length(ndr, &r->config_file));
7635                         }
7636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7639                 }
7640         }
7641         return NDR_ERR_SUCCESS;
7642 }
7643
7644 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7645 {
7646         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7647         ndr->depth++;
7648         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7649         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7650         ndr->depth++;
7651         if (r->driver_name) {
7652                 ndr_print_string(ndr, "driver_name", r->driver_name);
7653         }
7654         ndr->depth--;
7655         ndr_print_ptr(ndr, "architecture", r->architecture);
7656         ndr->depth++;
7657         if (r->architecture) {
7658                 ndr_print_string(ndr, "architecture", r->architecture);
7659         }
7660         ndr->depth--;
7661         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7662         ndr->depth++;
7663         if (r->driver_path) {
7664                 ndr_print_string(ndr, "driver_path", r->driver_path);
7665         }
7666         ndr->depth--;
7667         ndr_print_ptr(ndr, "data_file", r->data_file);
7668         ndr->depth++;
7669         if (r->data_file) {
7670                 ndr_print_string(ndr, "data_file", r->data_file);
7671         }
7672         ndr->depth--;
7673         ndr_print_ptr(ndr, "config_file", r->config_file);
7674         ndr->depth++;
7675         if (r->config_file) {
7676                 ndr_print_string(ndr, "config_file", r->config_file);
7677         }
7678         ndr->depth--;
7679         ndr->depth--;
7680 }
7681
7682 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7683 {
7684         if (ndr_flags & NDR_SCALARS) {
7685                 NDR_CHECK(ndr_push_align(ndr, 4));
7686                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7697         }
7698         if (ndr_flags & NDR_BUFFERS) {
7699                 if (r->driver_name) {
7700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7704                 }
7705                 if (r->architecture) {
7706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7710                 }
7711                 if (r->driver_path) {
7712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7716                 }
7717                 if (r->data_file) {
7718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7721                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7722                 }
7723                 if (r->config_file) {
7724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, 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->config_file, CH_UTF16)));
7727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7728                 }
7729                 if (r->help_file) {
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, 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->help_file, CH_UTF16)));
7733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7734                 }
7735                 if (r->monitor_name) {
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, 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->monitor_name, CH_UTF16)));
7739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7740                 }
7741                 if (r->default_datatype) {
7742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, 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->default_datatype, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7746                 }
7747                 if (r->dependent_files) {
7748                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7749                 }
7750         }
7751         return NDR_ERR_SUCCESS;
7752 }
7753
7754 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7755 {
7756         uint32_t _ptr_driver_name;
7757         TALLOC_CTX *_mem_save_driver_name_0;
7758         uint32_t _ptr_architecture;
7759         TALLOC_CTX *_mem_save_architecture_0;
7760         uint32_t _ptr_driver_path;
7761         TALLOC_CTX *_mem_save_driver_path_0;
7762         uint32_t _ptr_data_file;
7763         TALLOC_CTX *_mem_save_data_file_0;
7764         uint32_t _ptr_config_file;
7765         TALLOC_CTX *_mem_save_config_file_0;
7766         uint32_t _ptr_help_file;
7767         TALLOC_CTX *_mem_save_help_file_0;
7768         uint32_t _ptr_monitor_name;
7769         TALLOC_CTX *_mem_save_monitor_name_0;
7770         uint32_t _ptr_default_datatype;
7771         TALLOC_CTX *_mem_save_default_datatype_0;
7772         uint32_t _ptr_dependent_files;
7773         TALLOC_CTX *_mem_save_dependent_files_0;
7774         if (ndr_flags & NDR_SCALARS) {
7775                 NDR_CHECK(ndr_pull_align(ndr, 4));
7776                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7778                 if (_ptr_driver_name) {
7779                         NDR_PULL_ALLOC(ndr, r->driver_name);
7780                 } else {
7781                         r->driver_name = NULL;
7782                 }
7783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7784                 if (_ptr_architecture) {
7785                         NDR_PULL_ALLOC(ndr, r->architecture);
7786                 } else {
7787                         r->architecture = NULL;
7788                 }
7789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7790                 if (_ptr_driver_path) {
7791                         NDR_PULL_ALLOC(ndr, r->driver_path);
7792                 } else {
7793                         r->driver_path = NULL;
7794                 }
7795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7796                 if (_ptr_data_file) {
7797                         NDR_PULL_ALLOC(ndr, r->data_file);
7798                 } else {
7799                         r->data_file = NULL;
7800                 }
7801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7802                 if (_ptr_config_file) {
7803                         NDR_PULL_ALLOC(ndr, r->config_file);
7804                 } else {
7805                         r->config_file = NULL;
7806                 }
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7808                 if (_ptr_help_file) {
7809                         NDR_PULL_ALLOC(ndr, r->help_file);
7810                 } else {
7811                         r->help_file = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7814                 if (_ptr_monitor_name) {
7815                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7816                 } else {
7817                         r->monitor_name = NULL;
7818                 }
7819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7820                 if (_ptr_default_datatype) {
7821                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7822                 } else {
7823                         r->default_datatype = NULL;
7824                 }
7825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7827                 if (_ptr_dependent_files) {
7828                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7829                 } else {
7830                         r->dependent_files = NULL;
7831                 }
7832         }
7833         if (ndr_flags & NDR_BUFFERS) {
7834                 if (r->driver_name) {
7835                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7836                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7838                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7839                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7840                                 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));
7841                         }
7842                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7843                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7845                 }
7846                 if (r->architecture) {
7847                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7848                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7851                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7852                                 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));
7853                         }
7854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7857                 }
7858                 if (r->driver_path) {
7859                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7863                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
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_path), ndr_get_array_length(ndr, &r->driver_path));
7865                         }
7866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7869                 }
7870                 if (r->data_file) {
7871                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7872                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7875                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
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->data_file), ndr_get_array_length(ndr, &r->data_file));
7877                         }
7878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7881                 }
7882                 if (r->config_file) {
7883                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7884                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7887                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
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->config_file), ndr_get_array_length(ndr, &r->config_file));
7889                         }
7890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7893                 }
7894                 if (r->help_file) {
7895                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7896                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7899                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_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->help_file), ndr_get_array_length(ndr, &r->help_file));
7901                         }
7902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7905                 }
7906                 if (r->monitor_name) {
7907                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7908                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7911                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
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->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
7913                         }
7914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7917                 }
7918                 if (r->default_datatype) {
7919                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7923                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
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->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
7925                         }
7926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7929                 }
7930                 if (r->dependent_files) {
7931                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7932                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7933                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7935                 }
7936         }
7937         return NDR_ERR_SUCCESS;
7938 }
7939
7940 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7941 {
7942         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7943         ndr->depth++;
7944         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7945         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7946         ndr->depth++;
7947         if (r->driver_name) {
7948                 ndr_print_string(ndr, "driver_name", r->driver_name);
7949         }
7950         ndr->depth--;
7951         ndr_print_ptr(ndr, "architecture", r->architecture);
7952         ndr->depth++;
7953         if (r->architecture) {
7954                 ndr_print_string(ndr, "architecture", r->architecture);
7955         }
7956         ndr->depth--;
7957         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7958         ndr->depth++;
7959         if (r->driver_path) {
7960                 ndr_print_string(ndr, "driver_path", r->driver_path);
7961         }
7962         ndr->depth--;
7963         ndr_print_ptr(ndr, "data_file", r->data_file);
7964         ndr->depth++;
7965         if (r->data_file) {
7966                 ndr_print_string(ndr, "data_file", r->data_file);
7967         }
7968         ndr->depth--;
7969         ndr_print_ptr(ndr, "config_file", r->config_file);
7970         ndr->depth++;
7971         if (r->config_file) {
7972                 ndr_print_string(ndr, "config_file", r->config_file);
7973         }
7974         ndr->depth--;
7975         ndr_print_ptr(ndr, "help_file", r->help_file);
7976         ndr->depth++;
7977         if (r->help_file) {
7978                 ndr_print_string(ndr, "help_file", r->help_file);
7979         }
7980         ndr->depth--;
7981         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7982         ndr->depth++;
7983         if (r->monitor_name) {
7984                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7985         }
7986         ndr->depth--;
7987         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7988         ndr->depth++;
7989         if (r->default_datatype) {
7990                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7991         }
7992         ndr->depth--;
7993         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);
7994         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7995         ndr->depth++;
7996         if (r->dependent_files) {
7997                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7998         }
7999         ndr->depth--;
8000         ndr->depth--;
8001 }
8002
8003 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8004 {
8005         if (ndr_flags & NDR_SCALARS) {
8006                 NDR_CHECK(ndr_push_align(ndr, 4));
8007                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8009                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8020         }
8021         if (ndr_flags & NDR_BUFFERS) {
8022                 if (r->driver_name) {
8023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8027                 }
8028                 if (r->architecture) {
8029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8033                 }
8034                 if (r->driver_path) {
8035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8038                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8039                 }
8040                 if (r->data_file) {
8041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8044                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8045                 }
8046                 if (r->config_file) {
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, 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->config_file, CH_UTF16)));
8050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8051                 }
8052                 if (r->help_file) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, 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->help_file, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 if (r->monitor_name) {
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, 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->monitor_name, CH_UTF16)));
8062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8063                 }
8064                 if (r->default_datatype) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, 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->default_datatype, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 if (r->dependent_files) {
8071                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8072                 }
8073                 if (r->previous_names) {
8074                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8075                 }
8076         }
8077         return NDR_ERR_SUCCESS;
8078 }
8079
8080 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8081 {
8082         uint32_t _ptr_driver_name;
8083         TALLOC_CTX *_mem_save_driver_name_0;
8084         uint32_t _ptr_architecture;
8085         TALLOC_CTX *_mem_save_architecture_0;
8086         uint32_t _ptr_driver_path;
8087         TALLOC_CTX *_mem_save_driver_path_0;
8088         uint32_t _ptr_data_file;
8089         TALLOC_CTX *_mem_save_data_file_0;
8090         uint32_t _ptr_config_file;
8091         TALLOC_CTX *_mem_save_config_file_0;
8092         uint32_t _ptr_help_file;
8093         TALLOC_CTX *_mem_save_help_file_0;
8094         uint32_t _ptr_monitor_name;
8095         TALLOC_CTX *_mem_save_monitor_name_0;
8096         uint32_t _ptr_default_datatype;
8097         TALLOC_CTX *_mem_save_default_datatype_0;
8098         uint32_t _ptr_dependent_files;
8099         TALLOC_CTX *_mem_save_dependent_files_0;
8100         uint32_t _ptr_previous_names;
8101         TALLOC_CTX *_mem_save_previous_names_0;
8102         if (ndr_flags & NDR_SCALARS) {
8103                 NDR_CHECK(ndr_pull_align(ndr, 4));
8104                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8106                 if (_ptr_driver_name) {
8107                         NDR_PULL_ALLOC(ndr, r->driver_name);
8108                 } else {
8109                         r->driver_name = NULL;
8110                 }
8111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8112                 if (_ptr_architecture) {
8113                         NDR_PULL_ALLOC(ndr, r->architecture);
8114                 } else {
8115                         r->architecture = NULL;
8116                 }
8117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8118                 if (_ptr_driver_path) {
8119                         NDR_PULL_ALLOC(ndr, r->driver_path);
8120                 } else {
8121                         r->driver_path = NULL;
8122                 }
8123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8124                 if (_ptr_data_file) {
8125                         NDR_PULL_ALLOC(ndr, r->data_file);
8126                 } else {
8127                         r->data_file = NULL;
8128                 }
8129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8130                 if (_ptr_config_file) {
8131                         NDR_PULL_ALLOC(ndr, r->config_file);
8132                 } else {
8133                         r->config_file = NULL;
8134                 }
8135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8136                 if (_ptr_help_file) {
8137                         NDR_PULL_ALLOC(ndr, r->help_file);
8138                 } else {
8139                         r->help_file = NULL;
8140                 }
8141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8142                 if (_ptr_monitor_name) {
8143                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8144                 } else {
8145                         r->monitor_name = NULL;
8146                 }
8147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8148                 if (_ptr_default_datatype) {
8149                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8150                 } else {
8151                         r->default_datatype = NULL;
8152                 }
8153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8155                 if (_ptr_dependent_files) {
8156                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8157                 } else {
8158                         r->dependent_files = NULL;
8159                 }
8160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8162                 if (_ptr_previous_names) {
8163                         NDR_PULL_ALLOC(ndr, r->previous_names);
8164                 } else {
8165                         r->previous_names = NULL;
8166                 }
8167         }
8168         if (ndr_flags & NDR_BUFFERS) {
8169                 if (r->driver_name) {
8170                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8171                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8174                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8175                                 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));
8176                         }
8177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8180                 }
8181                 if (r->architecture) {
8182                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8183                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8186                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8187                                 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));
8188                         }
8189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8192                 }
8193                 if (r->driver_path) {
8194                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8195                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8198                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
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_path), ndr_get_array_length(ndr, &r->driver_path));
8200                         }
8201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8204                 }
8205                 if (r->data_file) {
8206                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8210                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
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->data_file), ndr_get_array_length(ndr, &r->data_file));
8212                         }
8213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8216                 }
8217                 if (r->config_file) {
8218                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8219                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8222                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
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->config_file), ndr_get_array_length(ndr, &r->config_file));
8224                         }
8225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8228                 }
8229                 if (r->help_file) {
8230                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8231                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8234                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_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->help_file), ndr_get_array_length(ndr, &r->help_file));
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8240                 }
8241                 if (r->monitor_name) {
8242                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8243                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8246                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
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->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8248                         }
8249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8252                 }
8253                 if (r->default_datatype) {
8254                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8255                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8258                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
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->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8260                         }
8261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8264                 }
8265                 if (r->dependent_files) {
8266                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8267                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8268                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8270                 }
8271                 if (r->previous_names) {
8272                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8273                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8274                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8276                 }
8277         }
8278         return NDR_ERR_SUCCESS;
8279 }
8280
8281 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8282 {
8283         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8284         ndr->depth++;
8285         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8286         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8287         ndr->depth++;
8288         if (r->driver_name) {
8289                 ndr_print_string(ndr, "driver_name", r->driver_name);
8290         }
8291         ndr->depth--;
8292         ndr_print_ptr(ndr, "architecture", r->architecture);
8293         ndr->depth++;
8294         if (r->architecture) {
8295                 ndr_print_string(ndr, "architecture", r->architecture);
8296         }
8297         ndr->depth--;
8298         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8299         ndr->depth++;
8300         if (r->driver_path) {
8301                 ndr_print_string(ndr, "driver_path", r->driver_path);
8302         }
8303         ndr->depth--;
8304         ndr_print_ptr(ndr, "data_file", r->data_file);
8305         ndr->depth++;
8306         if (r->data_file) {
8307                 ndr_print_string(ndr, "data_file", r->data_file);
8308         }
8309         ndr->depth--;
8310         ndr_print_ptr(ndr, "config_file", r->config_file);
8311         ndr->depth++;
8312         if (r->config_file) {
8313                 ndr_print_string(ndr, "config_file", r->config_file);
8314         }
8315         ndr->depth--;
8316         ndr_print_ptr(ndr, "help_file", r->help_file);
8317         ndr->depth++;
8318         if (r->help_file) {
8319                 ndr_print_string(ndr, "help_file", r->help_file);
8320         }
8321         ndr->depth--;
8322         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8323         ndr->depth++;
8324         if (r->monitor_name) {
8325                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8326         }
8327         ndr->depth--;
8328         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8329         ndr->depth++;
8330         if (r->default_datatype) {
8331                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8332         }
8333         ndr->depth--;
8334         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);
8335         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8336         ndr->depth++;
8337         if (r->dependent_files) {
8338                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8339         }
8340         ndr->depth--;
8341         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);
8342         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8343         ndr->depth++;
8344         if (r->previous_names) {
8345                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8346         }
8347         ndr->depth--;
8348         ndr->depth--;
8349 }
8350
8351 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8352 {
8353         if (ndr_flags & NDR_SCALARS) {
8354                 NDR_CHECK(ndr_push_align(ndr, 8));
8355                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8368                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8369                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8374         }
8375         if (ndr_flags & NDR_BUFFERS) {
8376                 if (r->driver_name) {
8377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8381                 }
8382                 if (r->architecture) {
8383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8387                 }
8388                 if (r->driver_path) {
8389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8393                 }
8394                 if (r->data_file) {
8395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8399                 }
8400                 if (r->config_file) {
8401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, 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->config_file, CH_UTF16)));
8404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8405                 }
8406                 if (r->help_file) {
8407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, 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->help_file, CH_UTF16)));
8410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8411                 }
8412                 if (r->monitor_name) {
8413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, 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->monitor_name, CH_UTF16)));
8416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8417                 }
8418                 if (r->default_datatype) {
8419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, 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->default_datatype, CH_UTF16)));
8422                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8423                 }
8424                 if (r->dependent_files) {
8425                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8426                 }
8427                 if (r->previous_names) {
8428                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8429                 }
8430                 if (r->manufacturer_name) {
8431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, 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->manufacturer_name, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8435                 }
8436                 if (r->manufacturer_url) {
8437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, 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->manufacturer_url, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8441                 }
8442                 if (r->hardware_id) {
8443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, 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->hardware_id, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8447                 }
8448                 if (r->provider) {
8449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8453                 }
8454         }
8455         return NDR_ERR_SUCCESS;
8456 }
8457
8458 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8459 {
8460         uint32_t _ptr_driver_name;
8461         TALLOC_CTX *_mem_save_driver_name_0;
8462         uint32_t _ptr_architecture;
8463         TALLOC_CTX *_mem_save_architecture_0;
8464         uint32_t _ptr_driver_path;
8465         TALLOC_CTX *_mem_save_driver_path_0;
8466         uint32_t _ptr_data_file;
8467         TALLOC_CTX *_mem_save_data_file_0;
8468         uint32_t _ptr_config_file;
8469         TALLOC_CTX *_mem_save_config_file_0;
8470         uint32_t _ptr_help_file;
8471         TALLOC_CTX *_mem_save_help_file_0;
8472         uint32_t _ptr_monitor_name;
8473         TALLOC_CTX *_mem_save_monitor_name_0;
8474         uint32_t _ptr_default_datatype;
8475         TALLOC_CTX *_mem_save_default_datatype_0;
8476         uint32_t _ptr_dependent_files;
8477         TALLOC_CTX *_mem_save_dependent_files_0;
8478         uint32_t _ptr_previous_names;
8479         TALLOC_CTX *_mem_save_previous_names_0;
8480         uint32_t _ptr_manufacturer_name;
8481         TALLOC_CTX *_mem_save_manufacturer_name_0;
8482         uint32_t _ptr_manufacturer_url;
8483         TALLOC_CTX *_mem_save_manufacturer_url_0;
8484         uint32_t _ptr_hardware_id;
8485         TALLOC_CTX *_mem_save_hardware_id_0;
8486         uint32_t _ptr_provider;
8487         TALLOC_CTX *_mem_save_provider_0;
8488         if (ndr_flags & NDR_SCALARS) {
8489                 NDR_CHECK(ndr_pull_align(ndr, 8));
8490                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8492                 if (_ptr_driver_name) {
8493                         NDR_PULL_ALLOC(ndr, r->driver_name);
8494                 } else {
8495                         r->driver_name = NULL;
8496                 }
8497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8498                 if (_ptr_architecture) {
8499                         NDR_PULL_ALLOC(ndr, r->architecture);
8500                 } else {
8501                         r->architecture = NULL;
8502                 }
8503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8504                 if (_ptr_driver_path) {
8505                         NDR_PULL_ALLOC(ndr, r->driver_path);
8506                 } else {
8507                         r->driver_path = NULL;
8508                 }
8509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8510                 if (_ptr_data_file) {
8511                         NDR_PULL_ALLOC(ndr, r->data_file);
8512                 } else {
8513                         r->data_file = NULL;
8514                 }
8515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8516                 if (_ptr_config_file) {
8517                         NDR_PULL_ALLOC(ndr, r->config_file);
8518                 } else {
8519                         r->config_file = NULL;
8520                 }
8521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8522                 if (_ptr_help_file) {
8523                         NDR_PULL_ALLOC(ndr, r->help_file);
8524                 } else {
8525                         r->help_file = NULL;
8526                 }
8527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8528                 if (_ptr_monitor_name) {
8529                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8530                 } else {
8531                         r->monitor_name = NULL;
8532                 }
8533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8534                 if (_ptr_default_datatype) {
8535                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8536                 } else {
8537                         r->default_datatype = NULL;
8538                 }
8539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8541                 if (_ptr_dependent_files) {
8542                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8543                 } else {
8544                         r->dependent_files = NULL;
8545                 }
8546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8548                 if (_ptr_previous_names) {
8549                         NDR_PULL_ALLOC(ndr, r->previous_names);
8550                 } else {
8551                         r->previous_names = NULL;
8552                 }
8553                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8554                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8556                 if (_ptr_manufacturer_name) {
8557                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8558                 } else {
8559                         r->manufacturer_name = NULL;
8560                 }
8561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8562                 if (_ptr_manufacturer_url) {
8563                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8564                 } else {
8565                         r->manufacturer_url = NULL;
8566                 }
8567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8568                 if (_ptr_hardware_id) {
8569                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8570                 } else {
8571                         r->hardware_id = NULL;
8572                 }
8573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8574                 if (_ptr_provider) {
8575                         NDR_PULL_ALLOC(ndr, r->provider);
8576                 } else {
8577                         r->provider = NULL;
8578                 }
8579         }
8580         if (ndr_flags & NDR_BUFFERS) {
8581                 if (r->driver_name) {
8582                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8583                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8586                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8587                                 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));
8588                         }
8589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8592                 }
8593                 if (r->architecture) {
8594                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8595                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8598                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8599                                 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));
8600                         }
8601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8604                 }
8605                 if (r->driver_path) {
8606                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8607                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8610                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
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_path), ndr_get_array_length(ndr, &r->driver_path));
8612                         }
8613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8616                 }
8617                 if (r->data_file) {
8618                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8619                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8622                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
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->data_file), ndr_get_array_length(ndr, &r->data_file));
8624                         }
8625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8628                 }
8629                 if (r->config_file) {
8630                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8631                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8634                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
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->config_file), ndr_get_array_length(ndr, &r->config_file));
8636                         }
8637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8640                 }
8641                 if (r->help_file) {
8642                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8646                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_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->help_file), ndr_get_array_length(ndr, &r->help_file));
8648                         }
8649                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8650                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8652                 }
8653                 if (r->monitor_name) {
8654                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8655                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8658                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
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->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8660                         }
8661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8664                 }
8665                 if (r->default_datatype) {
8666                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8667                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8668                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8669                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8670                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
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->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8672                         }
8673                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8674                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8676                 }
8677                 if (r->dependent_files) {
8678                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8679                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8680                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8682                 }
8683                 if (r->previous_names) {
8684                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8685                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8686                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8688                 }
8689                 if (r->manufacturer_name) {
8690                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8691                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8694                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
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->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
8696                         }
8697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8698                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8700                 }
8701                 if (r->manufacturer_url) {
8702                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8703                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8704                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8705                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8706                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8707                                 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));
8708                         }
8709                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8710                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8712                 }
8713                 if (r->hardware_id) {
8714                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8718                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
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->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
8720                         }
8721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8724                 }
8725                 if (r->provider) {
8726                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8727                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8730                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
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->provider), ndr_get_array_length(ndr, &r->provider));
8732                         }
8733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8736                 }
8737         }
8738         return NDR_ERR_SUCCESS;
8739 }
8740
8741 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8742 {
8743         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8744         ndr->depth++;
8745         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8746         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8747         ndr->depth++;
8748         if (r->driver_name) {
8749                 ndr_print_string(ndr, "driver_name", r->driver_name);
8750         }
8751         ndr->depth--;
8752         ndr_print_ptr(ndr, "architecture", r->architecture);
8753         ndr->depth++;
8754         if (r->architecture) {
8755                 ndr_print_string(ndr, "architecture", r->architecture);
8756         }
8757         ndr->depth--;
8758         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8759         ndr->depth++;
8760         if (r->driver_path) {
8761                 ndr_print_string(ndr, "driver_path", r->driver_path);
8762         }
8763         ndr->depth--;
8764         ndr_print_ptr(ndr, "data_file", r->data_file);
8765         ndr->depth++;
8766         if (r->data_file) {
8767                 ndr_print_string(ndr, "data_file", r->data_file);
8768         }
8769         ndr->depth--;
8770         ndr_print_ptr(ndr, "config_file", r->config_file);
8771         ndr->depth++;
8772         if (r->config_file) {
8773                 ndr_print_string(ndr, "config_file", r->config_file);
8774         }
8775         ndr->depth--;
8776         ndr_print_ptr(ndr, "help_file", r->help_file);
8777         ndr->depth++;
8778         if (r->help_file) {
8779                 ndr_print_string(ndr, "help_file", r->help_file);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8783         ndr->depth++;
8784         if (r->monitor_name) {
8785                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8789         ndr->depth++;
8790         if (r->default_datatype) {
8791                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8792         }
8793         ndr->depth--;
8794         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);
8795         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8796         ndr->depth++;
8797         if (r->dependent_files) {
8798                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8799         }
8800         ndr->depth--;
8801         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);
8802         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8803         ndr->depth++;
8804         if (r->previous_names) {
8805                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8806         }
8807         ndr->depth--;
8808         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8809         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8810         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8811         ndr->depth++;
8812         if (r->manufacturer_name) {
8813                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8814         }
8815         ndr->depth--;
8816         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8817         ndr->depth++;
8818         if (r->manufacturer_url) {
8819                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8820         }
8821         ndr->depth--;
8822         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8823         ndr->depth++;
8824         if (r->hardware_id) {
8825                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8826         }
8827         ndr->depth--;
8828         ndr_print_ptr(ndr, "provider", r->provider);
8829         ndr->depth++;
8830         if (r->provider) {
8831                 ndr_print_string(ndr, "provider", r->provider);
8832         }
8833         ndr->depth--;
8834         ndr->depth--;
8835 }
8836
8837 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8838 {
8839         if (ndr_flags & NDR_SCALARS) {
8840                 NDR_CHECK(ndr_push_align(ndr, 8));
8841                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8851                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8854                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8855                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8858                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8860                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8868                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8869                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8870         }
8871         if (ndr_flags & NDR_BUFFERS) {
8872                 if (r->driver_name) {
8873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8876                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8877                 }
8878                 if (r->architecture) {
8879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8883                 }
8884                 if (r->driver_path) {
8885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8886                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8888                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8889                 }
8890                 if (r->data_file) {
8891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8894                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8895                 }
8896                 if (r->config_file) {
8897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, 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->config_file, CH_UTF16)));
8900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8901                 }
8902                 if (r->help_file) {
8903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, 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->help_file, CH_UTF16)));
8906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8907                 }
8908                 if (r->monitor_name) {
8909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, 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->monitor_name, CH_UTF16)));
8912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8913                 }
8914                 if (r->default_datatype) {
8915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, 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->default_datatype, CH_UTF16)));
8918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8919                 }
8920                 if (r->dependent_files) {
8921                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8922                 }
8923                 if (r->previous_names) {
8924                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8925                 }
8926                 if (r->manufacturer_name) {
8927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, 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->manufacturer_name, CH_UTF16)));
8930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8931                 }
8932                 if (r->manufacturer_url) {
8933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, 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->manufacturer_url, CH_UTF16)));
8936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8937                 }
8938                 if (r->hardware_id) {
8939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, 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->hardware_id, CH_UTF16)));
8942                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8943                 }
8944                 if (r->provider) {
8945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8948                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8949                 }
8950                 if (r->print_processor) {
8951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, 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->print_processor, CH_UTF16)));
8954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8955                 }
8956                 if (r->vendor_setup) {
8957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, 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->vendor_setup, CH_UTF16)));
8960                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8961                 }
8962                 if (r->color_profiles) {
8963                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8964                 }
8965                 if (r->inf_path) {
8966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8968                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8970                 }
8971                 if (r->core_driver_dependencies) {
8972                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8973                 }
8974         }
8975         return NDR_ERR_SUCCESS;
8976 }
8977
8978 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
8979 {
8980         uint32_t _ptr_driver_name;
8981         TALLOC_CTX *_mem_save_driver_name_0;
8982         uint32_t _ptr_architecture;
8983         TALLOC_CTX *_mem_save_architecture_0;
8984         uint32_t _ptr_driver_path;
8985         TALLOC_CTX *_mem_save_driver_path_0;
8986         uint32_t _ptr_data_file;
8987         TALLOC_CTX *_mem_save_data_file_0;
8988         uint32_t _ptr_config_file;
8989         TALLOC_CTX *_mem_save_config_file_0;
8990         uint32_t _ptr_help_file;
8991         TALLOC_CTX *_mem_save_help_file_0;
8992         uint32_t _ptr_monitor_name;
8993         TALLOC_CTX *_mem_save_monitor_name_0;
8994         uint32_t _ptr_default_datatype;
8995         TALLOC_CTX *_mem_save_default_datatype_0;
8996         uint32_t _ptr_dependent_files;
8997         TALLOC_CTX *_mem_save_dependent_files_0;
8998         uint32_t _ptr_previous_names;
8999         TALLOC_CTX *_mem_save_previous_names_0;
9000         uint32_t _ptr_manufacturer_name;
9001         TALLOC_CTX *_mem_save_manufacturer_name_0;
9002         uint32_t _ptr_manufacturer_url;
9003         TALLOC_CTX *_mem_save_manufacturer_url_0;
9004         uint32_t _ptr_hardware_id;
9005         TALLOC_CTX *_mem_save_hardware_id_0;
9006         uint32_t _ptr_provider;
9007         TALLOC_CTX *_mem_save_provider_0;
9008         uint32_t _ptr_print_processor;
9009         TALLOC_CTX *_mem_save_print_processor_0;
9010         uint32_t _ptr_vendor_setup;
9011         TALLOC_CTX *_mem_save_vendor_setup_0;
9012         uint32_t _ptr_color_profiles;
9013         TALLOC_CTX *_mem_save_color_profiles_0;
9014         uint32_t _ptr_inf_path;
9015         TALLOC_CTX *_mem_save_inf_path_0;
9016         uint32_t _ptr_core_driver_dependencies;
9017         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9018         if (ndr_flags & NDR_SCALARS) {
9019                 NDR_CHECK(ndr_pull_align(ndr, 8));
9020                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9022                 if (_ptr_driver_name) {
9023                         NDR_PULL_ALLOC(ndr, r->driver_name);
9024                 } else {
9025                         r->driver_name = NULL;
9026                 }
9027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9028                 if (_ptr_architecture) {
9029                         NDR_PULL_ALLOC(ndr, r->architecture);
9030                 } else {
9031                         r->architecture = NULL;
9032                 }
9033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9034                 if (_ptr_driver_path) {
9035                         NDR_PULL_ALLOC(ndr, r->driver_path);
9036                 } else {
9037                         r->driver_path = NULL;
9038                 }
9039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9040                 if (_ptr_data_file) {
9041                         NDR_PULL_ALLOC(ndr, r->data_file);
9042                 } else {
9043                         r->data_file = NULL;
9044                 }
9045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9046                 if (_ptr_config_file) {
9047                         NDR_PULL_ALLOC(ndr, r->config_file);
9048                 } else {
9049                         r->config_file = NULL;
9050                 }
9051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9052                 if (_ptr_help_file) {
9053                         NDR_PULL_ALLOC(ndr, r->help_file);
9054                 } else {
9055                         r->help_file = NULL;
9056                 }
9057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9058                 if (_ptr_monitor_name) {
9059                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9060                 } else {
9061                         r->monitor_name = NULL;
9062                 }
9063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9064                 if (_ptr_default_datatype) {
9065                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9066                 } else {
9067                         r->default_datatype = NULL;
9068                 }
9069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9071                 if (_ptr_dependent_files) {
9072                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9073                 } else {
9074                         r->dependent_files = NULL;
9075                 }
9076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9078                 if (_ptr_previous_names) {
9079                         NDR_PULL_ALLOC(ndr, r->previous_names);
9080                 } else {
9081                         r->previous_names = NULL;
9082                 }
9083                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9084                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9086                 if (_ptr_manufacturer_name) {
9087                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9088                 } else {
9089                         r->manufacturer_name = NULL;
9090                 }
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9092                 if (_ptr_manufacturer_url) {
9093                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9094                 } else {
9095                         r->manufacturer_url = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9098                 if (_ptr_hardware_id) {
9099                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9100                 } else {
9101                         r->hardware_id = NULL;
9102                 }
9103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9104                 if (_ptr_provider) {
9105                         NDR_PULL_ALLOC(ndr, r->provider);
9106                 } else {
9107                         r->provider = NULL;
9108                 }
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9110                 if (_ptr_print_processor) {
9111                         NDR_PULL_ALLOC(ndr, r->print_processor);
9112                 } else {
9113                         r->print_processor = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9116                 if (_ptr_vendor_setup) {
9117                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9118                 } else {
9119                         r->vendor_setup = NULL;
9120                 }
9121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9123                 if (_ptr_color_profiles) {
9124                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9125                 } else {
9126                         r->color_profiles = NULL;
9127                 }
9128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9129                 if (_ptr_inf_path) {
9130                         NDR_PULL_ALLOC(ndr, r->inf_path);
9131                 } else {
9132                         r->inf_path = NULL;
9133                 }
9134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9137                 if (_ptr_core_driver_dependencies) {
9138                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9139                 } else {
9140                         r->core_driver_dependencies = NULL;
9141                 }
9142                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9143                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9144         }
9145         if (ndr_flags & NDR_BUFFERS) {
9146                 if (r->driver_name) {
9147                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9148                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9149                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9150                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9151                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9152                                 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));
9153                         }
9154                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9155                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9157                 }
9158                 if (r->architecture) {
9159                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9160                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9161                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9162                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9163                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9164                                 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));
9165                         }
9166                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9167                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9169                 }
9170                 if (r->driver_path) {
9171                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9172                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9175                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
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_path), ndr_get_array_length(ndr, &r->driver_path));
9177                         }
9178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9181                 }
9182                 if (r->data_file) {
9183                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9184                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9187                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
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->data_file), ndr_get_array_length(ndr, &r->data_file));
9189                         }
9190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9193                 }
9194                 if (r->config_file) {
9195                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9196                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9199                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
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->config_file), ndr_get_array_length(ndr, &r->config_file));
9201                         }
9202                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9203                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9205                 }
9206                 if (r->help_file) {
9207                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9211                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_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->help_file), ndr_get_array_length(ndr, &r->help_file));
9213                         }
9214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9215                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9217                 }
9218                 if (r->monitor_name) {
9219                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9220                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9221                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9222                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9223                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
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->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9225                         }
9226                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9227                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9229                 }
9230                 if (r->default_datatype) {
9231                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9235                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
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->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9237                         }
9238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9241                 }
9242                 if (r->dependent_files) {
9243                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9245                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9247                 }
9248                 if (r->previous_names) {
9249                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9250                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9251                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9253                 }
9254                 if (r->manufacturer_name) {
9255                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9256                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9259                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
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->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9261                         }
9262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9265                 }
9266                 if (r->manufacturer_url) {
9267                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9268                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9271                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9272                                 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));
9273                         }
9274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9277                 }
9278                 if (r->hardware_id) {
9279                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9283                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
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->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9285                         }
9286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9289                 }
9290                 if (r->provider) {
9291                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9292                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9295                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
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->provider), ndr_get_array_length(ndr, &r->provider));
9297                         }
9298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9301                 }
9302                 if (r->print_processor) {
9303                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9304                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9307                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
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->print_processor), ndr_get_array_length(ndr, &r->print_processor));
9309                         }
9310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9313                 }
9314                 if (r->vendor_setup) {
9315                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9316                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9319                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
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->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
9321                         }
9322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9325                 }
9326                 if (r->color_profiles) {
9327                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9328                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9329                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9331                 }
9332                 if (r->inf_path) {
9333                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9334                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9337                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9338                                 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));
9339                         }
9340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9343                 }
9344                 if (r->core_driver_dependencies) {
9345                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9346                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9347                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9349                 }
9350         }
9351         return NDR_ERR_SUCCESS;
9352 }
9353
9354 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9355 {
9356         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9357         ndr->depth++;
9358         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9359         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9360         ndr->depth++;
9361         if (r->driver_name) {
9362                 ndr_print_string(ndr, "driver_name", r->driver_name);
9363         }
9364         ndr->depth--;
9365         ndr_print_ptr(ndr, "architecture", r->architecture);
9366         ndr->depth++;
9367         if (r->architecture) {
9368                 ndr_print_string(ndr, "architecture", r->architecture);
9369         }
9370         ndr->depth--;
9371         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9372         ndr->depth++;
9373         if (r->driver_path) {
9374                 ndr_print_string(ndr, "driver_path", r->driver_path);
9375         }
9376         ndr->depth--;
9377         ndr_print_ptr(ndr, "data_file", r->data_file);
9378         ndr->depth++;
9379         if (r->data_file) {
9380                 ndr_print_string(ndr, "data_file", r->data_file);
9381         }
9382         ndr->depth--;
9383         ndr_print_ptr(ndr, "config_file", r->config_file);
9384         ndr->depth++;
9385         if (r->config_file) {
9386                 ndr_print_string(ndr, "config_file", r->config_file);
9387         }
9388         ndr->depth--;
9389         ndr_print_ptr(ndr, "help_file", r->help_file);
9390         ndr->depth++;
9391         if (r->help_file) {
9392                 ndr_print_string(ndr, "help_file", r->help_file);
9393         }
9394         ndr->depth--;
9395         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9396         ndr->depth++;
9397         if (r->monitor_name) {
9398                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9399         }
9400         ndr->depth--;
9401         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9402         ndr->depth++;
9403         if (r->default_datatype) {
9404                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9405         }
9406         ndr->depth--;
9407         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);
9408         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9409         ndr->depth++;
9410         if (r->dependent_files) {
9411                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9412         }
9413         ndr->depth--;
9414         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);
9415         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9416         ndr->depth++;
9417         if (r->previous_names) {
9418                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9419         }
9420         ndr->depth--;
9421         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9422         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9423         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9424         ndr->depth++;
9425         if (r->manufacturer_name) {
9426                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9427         }
9428         ndr->depth--;
9429         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9430         ndr->depth++;
9431         if (r->manufacturer_url) {
9432                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9433         }
9434         ndr->depth--;
9435         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9436         ndr->depth++;
9437         if (r->hardware_id) {
9438                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9439         }
9440         ndr->depth--;
9441         ndr_print_ptr(ndr, "provider", r->provider);
9442         ndr->depth++;
9443         if (r->provider) {
9444                 ndr_print_string(ndr, "provider", r->provider);
9445         }
9446         ndr->depth--;
9447         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9448         ndr->depth++;
9449         if (r->print_processor) {
9450                 ndr_print_string(ndr, "print_processor", r->print_processor);
9451         }
9452         ndr->depth--;
9453         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9454         ndr->depth++;
9455         if (r->vendor_setup) {
9456                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9457         }
9458         ndr->depth--;
9459         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);
9460         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9461         ndr->depth++;
9462         if (r->color_profiles) {
9463                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9464         }
9465         ndr->depth--;
9466         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9467         ndr->depth++;
9468         if (r->inf_path) {
9469                 ndr_print_string(ndr, "inf_path", r->inf_path);
9470         }
9471         ndr->depth--;
9472         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9473         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);
9474         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9475         ndr->depth++;
9476         if (r->core_driver_dependencies) {
9477                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9478         }
9479         ndr->depth--;
9480         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9481         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9482         ndr->depth--;
9483 }
9484
9485 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9486 {
9487         if (ndr_flags & NDR_SCALARS) {
9488                 int level = ndr_push_get_switch_value(ndr, r);
9489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9490                 switch (level) {
9491                         case 1: {
9492                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9493                         break; }
9494
9495                         case 2: {
9496                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9497                         break; }
9498
9499                         case 3: {
9500                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9501                         break; }
9502
9503                         case 4: {
9504                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9505                         break; }
9506
9507                         case 6: {
9508                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9509                         break; }
9510
9511                         case 8: {
9512                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9513                         break; }
9514
9515                         default:
9516                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9517                 }
9518         }
9519         if (ndr_flags & NDR_BUFFERS) {
9520                 int level = ndr_push_get_switch_value(ndr, r);
9521                 switch (level) {
9522                         case 1:
9523                                 if (r->info1) {
9524                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9525                                 }
9526                         break;
9527
9528                         case 2:
9529                                 if (r->info2) {
9530                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9531                                 }
9532                         break;
9533
9534                         case 3:
9535                                 if (r->info3) {
9536                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9537                                 }
9538                         break;
9539
9540                         case 4:
9541                                 if (r->info4) {
9542                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9543                                 }
9544                         break;
9545
9546                         case 6:
9547                                 if (r->info6) {
9548                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9549                                 }
9550                         break;
9551
9552                         case 8:
9553                                 if (r->info8) {
9554                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9555                                 }
9556                         break;
9557
9558                         default:
9559                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9560                 }
9561         }
9562         return NDR_ERR_SUCCESS;
9563 }
9564
9565 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9566 {
9567         int level;
9568         uint32_t _level;
9569         TALLOC_CTX *_mem_save_info1_0;
9570         TALLOC_CTX *_mem_save_info2_0;
9571         TALLOC_CTX *_mem_save_info3_0;
9572         TALLOC_CTX *_mem_save_info4_0;
9573         TALLOC_CTX *_mem_save_info6_0;
9574         TALLOC_CTX *_mem_save_info8_0;
9575         level = ndr_pull_get_switch_value(ndr, r);
9576         if (ndr_flags & NDR_SCALARS) {
9577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9578                 if (_level != level) {
9579                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9580                 }
9581                 switch (level) {
9582                         case 1: {
9583                                 uint32_t _ptr_info1;
9584                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9585                                 if (_ptr_info1) {
9586                                         NDR_PULL_ALLOC(ndr, r->info1);
9587                                 } else {
9588                                         r->info1 = NULL;
9589                                 }
9590                         break; }
9591
9592                         case 2: {
9593                                 uint32_t _ptr_info2;
9594                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9595                                 if (_ptr_info2) {
9596                                         NDR_PULL_ALLOC(ndr, r->info2);
9597                                 } else {
9598                                         r->info2 = NULL;
9599                                 }
9600                         break; }
9601
9602                         case 3: {
9603                                 uint32_t _ptr_info3;
9604                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9605                                 if (_ptr_info3) {
9606                                         NDR_PULL_ALLOC(ndr, r->info3);
9607                                 } else {
9608                                         r->info3 = NULL;
9609                                 }
9610                         break; }
9611
9612                         case 4: {
9613                                 uint32_t _ptr_info4;
9614                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9615                                 if (_ptr_info4) {
9616                                         NDR_PULL_ALLOC(ndr, r->info4);
9617                                 } else {
9618                                         r->info4 = NULL;
9619                                 }
9620                         break; }
9621
9622                         case 6: {
9623                                 uint32_t _ptr_info6;
9624                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9625                                 if (_ptr_info6) {
9626                                         NDR_PULL_ALLOC(ndr, r->info6);
9627                                 } else {
9628                                         r->info6 = NULL;
9629                                 }
9630                         break; }
9631
9632                         case 8: {
9633                                 uint32_t _ptr_info8;
9634                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9635                                 if (_ptr_info8) {
9636                                         NDR_PULL_ALLOC(ndr, r->info8);
9637                                 } else {
9638                                         r->info8 = NULL;
9639                                 }
9640                         break; }
9641
9642                         default:
9643                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9644                 }
9645         }
9646         if (ndr_flags & NDR_BUFFERS) {
9647                 switch (level) {
9648                         case 1:
9649                                 if (r->info1) {
9650                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9652                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9654                                 }
9655                         break;
9656
9657                         case 2:
9658                                 if (r->info2) {
9659                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9660                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9661                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9662                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9663                                 }
9664                         break;
9665
9666                         case 3:
9667                                 if (r->info3) {
9668                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9669                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9670                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9671                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9672                                 }
9673                         break;
9674
9675                         case 4:
9676                                 if (r->info4) {
9677                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9678                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9679                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9680                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9681                                 }
9682                         break;
9683
9684                         case 6:
9685                                 if (r->info6) {
9686                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9687                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9688                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9689                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9690                                 }
9691                         break;
9692
9693                         case 8:
9694                                 if (r->info8) {
9695                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9696                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9697                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9698                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9699                                 }
9700                         break;
9701
9702                         default:
9703                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9704                 }
9705         }
9706         return NDR_ERR_SUCCESS;
9707 }
9708
9709 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9710 {
9711         int level;
9712         level = ndr_print_get_switch_value(ndr, r);
9713         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9714         switch (level) {
9715                 case 1:
9716                         ndr_print_ptr(ndr, "info1", r->info1);
9717                         ndr->depth++;
9718                         if (r->info1) {
9719                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9720                         }
9721                         ndr->depth--;
9722                 break;
9723
9724                 case 2:
9725                         ndr_print_ptr(ndr, "info2", r->info2);
9726                         ndr->depth++;
9727                         if (r->info2) {
9728                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9729                         }
9730                         ndr->depth--;
9731                 break;
9732
9733                 case 3:
9734                         ndr_print_ptr(ndr, "info3", r->info3);
9735                         ndr->depth++;
9736                         if (r->info3) {
9737                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9738                         }
9739                         ndr->depth--;
9740                 break;
9741
9742                 case 4:
9743                         ndr_print_ptr(ndr, "info4", r->info4);
9744                         ndr->depth++;
9745                         if (r->info4) {
9746                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9747                         }
9748                         ndr->depth--;
9749                 break;
9750
9751                 case 6:
9752                         ndr_print_ptr(ndr, "info6", r->info6);
9753                         ndr->depth++;
9754                         if (r->info6) {
9755                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9756                         }
9757                         ndr->depth--;
9758                 break;
9759
9760                 case 8:
9761                         ndr_print_ptr(ndr, "info8", r->info8);
9762                         ndr->depth++;
9763                         if (r->info8) {
9764                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9765                         }
9766                         ndr->depth--;
9767                 break;
9768
9769                 default:
9770                         ndr_print_bad_level(ndr, name, level);
9771         }
9772 }
9773
9774 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9775 {
9776         if (ndr_flags & NDR_SCALARS) {
9777                 NDR_CHECK(ndr_push_align(ndr, 4));
9778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9779                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9780                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9781         }
9782         if (ndr_flags & NDR_BUFFERS) {
9783                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9784         }
9785         return NDR_ERR_SUCCESS;
9786 }
9787
9788 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9789 {
9790         if (ndr_flags & NDR_SCALARS) {
9791                 NDR_CHECK(ndr_pull_align(ndr, 4));
9792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9793                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9794                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9795         }
9796         if (ndr_flags & NDR_BUFFERS) {
9797                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9798         }
9799         return NDR_ERR_SUCCESS;
9800 }
9801
9802 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9803 {
9804         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9805         ndr->depth++;
9806         ndr_print_uint32(ndr, "level", r->level);
9807         ndr_print_set_switch_value(ndr, &r->info, r->level);
9808         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9809         ndr->depth--;
9810 }
9811
9812 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9813 {
9814         if (ndr_flags & NDR_SCALARS) {
9815                 NDR_CHECK(ndr_push_align(ndr, 4));
9816                 {
9817                         uint32_t _flags_save_string = ndr->flags;
9818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9819                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9820                         ndr->flags = _flags_save_string;
9821                 }
9822         }
9823         if (ndr_flags & NDR_BUFFERS) {
9824                 {
9825                         uint32_t _flags_save_string = ndr->flags;
9826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9827                         if (r->driver_name) {
9828                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9829                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9830                         }
9831                         ndr->flags = _flags_save_string;
9832                 }
9833         }
9834         return NDR_ERR_SUCCESS;
9835 }
9836
9837 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9838 {
9839         uint32_t _ptr_driver_name;
9840         TALLOC_CTX *_mem_save_driver_name_0;
9841         if (ndr_flags & NDR_SCALARS) {
9842                 NDR_CHECK(ndr_pull_align(ndr, 4));
9843                 {
9844                         uint32_t _flags_save_string = ndr->flags;
9845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9847                         if (_ptr_driver_name) {
9848                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9850                         } else {
9851                                 r->driver_name = NULL;
9852                         }
9853                         ndr->flags = _flags_save_string;
9854                 }
9855         }
9856         if (ndr_flags & NDR_BUFFERS) {
9857                 {
9858                         uint32_t _flags_save_string = ndr->flags;
9859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9860                         if (r->driver_name) {
9861                                 uint32_t _relative_save_offset;
9862                                 _relative_save_offset = ndr->offset;
9863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9864                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9865                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9868                                 ndr->offset = _relative_save_offset;
9869                         }
9870                         ndr->flags = _flags_save_string;
9871                 }
9872         }
9873         return NDR_ERR_SUCCESS;
9874 }
9875
9876 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9877 {
9878         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9879         ndr->depth++;
9880         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9881         ndr->depth++;
9882         if (r->driver_name) {
9883                 ndr_print_string(ndr, "driver_name", r->driver_name);
9884         }
9885         ndr->depth--;
9886         ndr->depth--;
9887 }
9888
9889 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9890 {
9891         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9892 }
9893
9894 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9895 {
9896         if (ndr_flags & NDR_SCALARS) {
9897                 NDR_CHECK(ndr_push_align(ndr, 4));
9898                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9899                 {
9900                         uint32_t _flags_save_string = ndr->flags;
9901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9902                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9903                         ndr->flags = _flags_save_string;
9904                 }
9905                 {
9906                         uint32_t _flags_save_string = ndr->flags;
9907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9909                         ndr->flags = _flags_save_string;
9910                 }
9911                 {
9912                         uint32_t _flags_save_string = ndr->flags;
9913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9914                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9915                         ndr->flags = _flags_save_string;
9916                 }
9917                 {
9918                         uint32_t _flags_save_string = ndr->flags;
9919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9920                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9921                         ndr->flags = _flags_save_string;
9922                 }
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->config_file));
9927                         ndr->flags = _flags_save_string;
9928                 }
9929         }
9930         if (ndr_flags & NDR_BUFFERS) {
9931                 {
9932                         uint32_t _flags_save_string = ndr->flags;
9933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9934                         if (r->driver_name) {
9935                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9936                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9937                         }
9938                         ndr->flags = _flags_save_string;
9939                 }
9940                 {
9941                         uint32_t _flags_save_string = ndr->flags;
9942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9943                         if (r->architecture) {
9944                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9945                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9946                         }
9947                         ndr->flags = _flags_save_string;
9948                 }
9949                 {
9950                         uint32_t _flags_save_string = ndr->flags;
9951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9952                         if (r->driver_path) {
9953                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9955                         }
9956                         ndr->flags = _flags_save_string;
9957                 }
9958                 {
9959                         uint32_t _flags_save_string = ndr->flags;
9960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9961                         if (r->data_file) {
9962                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9963                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9964                         }
9965                         ndr->flags = _flags_save_string;
9966                 }
9967                 {
9968                         uint32_t _flags_save_string = ndr->flags;
9969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9970                         if (r->config_file) {
9971                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9972                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9973                         }
9974                         ndr->flags = _flags_save_string;
9975                 }
9976         }
9977         return NDR_ERR_SUCCESS;
9978 }
9979
9980 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
9981 {
9982         uint32_t _ptr_driver_name;
9983         TALLOC_CTX *_mem_save_driver_name_0;
9984         uint32_t _ptr_architecture;
9985         TALLOC_CTX *_mem_save_architecture_0;
9986         uint32_t _ptr_driver_path;
9987         TALLOC_CTX *_mem_save_driver_path_0;
9988         uint32_t _ptr_data_file;
9989         TALLOC_CTX *_mem_save_data_file_0;
9990         uint32_t _ptr_config_file;
9991         TALLOC_CTX *_mem_save_config_file_0;
9992         if (ndr_flags & NDR_SCALARS) {
9993                 NDR_CHECK(ndr_pull_align(ndr, 4));
9994                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9995                 {
9996                         uint32_t _flags_save_string = ndr->flags;
9997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9998                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9999                         if (_ptr_driver_name) {
10000                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10001                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10002                         } else {
10003                                 r->driver_name = NULL;
10004                         }
10005                         ndr->flags = _flags_save_string;
10006                 }
10007                 {
10008                         uint32_t _flags_save_string = ndr->flags;
10009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10010                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10011                         if (_ptr_architecture) {
10012                                 NDR_PULL_ALLOC(ndr, r->architecture);
10013                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10014                         } else {
10015                                 r->architecture = NULL;
10016                         }
10017                         ndr->flags = _flags_save_string;
10018                 }
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_path));
10023                         if (_ptr_driver_path) {
10024                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10025                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10026                         } else {
10027                                 r->driver_path = 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_data_file));
10035                         if (_ptr_data_file) {
10036                                 NDR_PULL_ALLOC(ndr, r->data_file);
10037                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10038                         } else {
10039                                 r->data_file = 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_config_file));
10047                         if (_ptr_config_file) {
10048                                 NDR_PULL_ALLOC(ndr, r->config_file);
10049                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10050                         } else {
10051                                 r->config_file = NULL;
10052                         }
10053                         ndr->flags = _flags_save_string;
10054                 }
10055         }
10056         if (ndr_flags & NDR_BUFFERS) {
10057                 {
10058                         uint32_t _flags_save_string = ndr->flags;
10059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10060                         if (r->driver_name) {
10061                                 uint32_t _relative_save_offset;
10062                                 _relative_save_offset = ndr->offset;
10063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10064                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10065                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10066                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10068                                 ndr->offset = _relative_save_offset;
10069                         }
10070                         ndr->flags = _flags_save_string;
10071                 }
10072                 {
10073                         uint32_t _flags_save_string = ndr->flags;
10074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10075                         if (r->architecture) {
10076                                 uint32_t _relative_save_offset;
10077                                 _relative_save_offset = ndr->offset;
10078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10079                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10080                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10083                                 ndr->offset = _relative_save_offset;
10084                         }
10085                         ndr->flags = _flags_save_string;
10086                 }
10087                 {
10088                         uint32_t _flags_save_string = ndr->flags;
10089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10090                         if (r->driver_path) {
10091                                 uint32_t _relative_save_offset;
10092                                 _relative_save_offset = ndr->offset;
10093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10094                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10095                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10098                                 ndr->offset = _relative_save_offset;
10099                         }
10100                         ndr->flags = _flags_save_string;
10101                 }
10102                 {
10103                         uint32_t _flags_save_string = ndr->flags;
10104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10105                         if (r->data_file) {
10106                                 uint32_t _relative_save_offset;
10107                                 _relative_save_offset = ndr->offset;
10108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10109                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10110                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10111                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10113                                 ndr->offset = _relative_save_offset;
10114                         }
10115                         ndr->flags = _flags_save_string;
10116                 }
10117                 {
10118                         uint32_t _flags_save_string = ndr->flags;
10119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10120                         if (r->config_file) {
10121                                 uint32_t _relative_save_offset;
10122                                 _relative_save_offset = ndr->offset;
10123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10124                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10125                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10128                                 ndr->offset = _relative_save_offset;
10129                         }
10130                         ndr->flags = _flags_save_string;
10131                 }
10132         }
10133         return NDR_ERR_SUCCESS;
10134 }
10135
10136 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10137 {
10138         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10139         ndr->depth++;
10140         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10141         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10142         ndr->depth++;
10143         if (r->driver_name) {
10144                 ndr_print_string(ndr, "driver_name", r->driver_name);
10145         }
10146         ndr->depth--;
10147         ndr_print_ptr(ndr, "architecture", r->architecture);
10148         ndr->depth++;
10149         if (r->architecture) {
10150                 ndr_print_string(ndr, "architecture", r->architecture);
10151         }
10152         ndr->depth--;
10153         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10154         ndr->depth++;
10155         if (r->driver_path) {
10156                 ndr_print_string(ndr, "driver_path", r->driver_path);
10157         }
10158         ndr->depth--;
10159         ndr_print_ptr(ndr, "data_file", r->data_file);
10160         ndr->depth++;
10161         if (r->data_file) {
10162                 ndr_print_string(ndr, "data_file", r->data_file);
10163         }
10164         ndr->depth--;
10165         ndr_print_ptr(ndr, "config_file", r->config_file);
10166         ndr->depth++;
10167         if (r->config_file) {
10168                 ndr_print_string(ndr, "config_file", r->config_file);
10169         }
10170         ndr->depth--;
10171         ndr->depth--;
10172 }
10173
10174 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10175 {
10176         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10177 }
10178
10179 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10180 {
10181         if (ndr_flags & NDR_SCALARS) {
10182                 NDR_CHECK(ndr_push_align(ndr, 4));
10183                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10184                 {
10185                         uint32_t _flags_save_string = ndr->flags;
10186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10187                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10188                         ndr->flags = _flags_save_string;
10189                 }
10190                 {
10191                         uint32_t _flags_save_string = ndr->flags;
10192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10193                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10194                         ndr->flags = _flags_save_string;
10195                 }
10196                 {
10197                         uint32_t _flags_save_string = ndr->flags;
10198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10199                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10200                         ndr->flags = _flags_save_string;
10201                 }
10202                 {
10203                         uint32_t _flags_save_string = ndr->flags;
10204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10205                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10206                         ndr->flags = _flags_save_string;
10207                 }
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->config_file));
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->help_file));
10218                         ndr->flags = _flags_save_string;
10219                 }
10220                 {
10221                         uint32_t _flags_save_string_array = ndr->flags;
10222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10224                         ndr->flags = _flags_save_string_array;
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->monitor_name));
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->default_datatype));
10236                         ndr->flags = _flags_save_string;
10237                 }
10238         }
10239         if (ndr_flags & NDR_BUFFERS) {
10240                 {
10241                         uint32_t _flags_save_string = ndr->flags;
10242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10243                         if (r->driver_name) {
10244                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10245                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10246                         }
10247                         ndr->flags = _flags_save_string;
10248                 }
10249                 {
10250                         uint32_t _flags_save_string = ndr->flags;
10251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10252                         if (r->architecture) {
10253                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10254                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10255                         }
10256                         ndr->flags = _flags_save_string;
10257                 }
10258                 {
10259                         uint32_t _flags_save_string = ndr->flags;
10260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10261                         if (r->driver_path) {
10262                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10263                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10264                         }
10265                         ndr->flags = _flags_save_string;
10266                 }
10267                 {
10268                         uint32_t _flags_save_string = ndr->flags;
10269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10270                         if (r->data_file) {
10271                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10273                         }
10274                         ndr->flags = _flags_save_string;
10275                 }
10276                 {
10277                         uint32_t _flags_save_string = ndr->flags;
10278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10279                         if (r->config_file) {
10280                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10281                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10282                         }
10283                         ndr->flags = _flags_save_string;
10284                 }
10285                 {
10286                         uint32_t _flags_save_string = ndr->flags;
10287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10288                         if (r->help_file) {
10289                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10291                         }
10292                         ndr->flags = _flags_save_string;
10293                 }
10294                 {
10295                         uint32_t _flags_save_string_array = ndr->flags;
10296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10297                         if (r->dependent_files) {
10298                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10299                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10300                         }
10301                         ndr->flags = _flags_save_string_array;
10302                 }
10303                 {
10304                         uint32_t _flags_save_string = ndr->flags;
10305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10306                         if (r->monitor_name) {
10307                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10309                         }
10310                         ndr->flags = _flags_save_string;
10311                 }
10312                 {
10313                         uint32_t _flags_save_string = ndr->flags;
10314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10315                         if (r->default_datatype) {
10316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10318                         }
10319                         ndr->flags = _flags_save_string;
10320                 }
10321         }
10322         return NDR_ERR_SUCCESS;
10323 }
10324
10325 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10326 {
10327         uint32_t _ptr_driver_name;
10328         TALLOC_CTX *_mem_save_driver_name_0;
10329         uint32_t _ptr_architecture;
10330         TALLOC_CTX *_mem_save_architecture_0;
10331         uint32_t _ptr_driver_path;
10332         TALLOC_CTX *_mem_save_driver_path_0;
10333         uint32_t _ptr_data_file;
10334         TALLOC_CTX *_mem_save_data_file_0;
10335         uint32_t _ptr_config_file;
10336         TALLOC_CTX *_mem_save_config_file_0;
10337         uint32_t _ptr_help_file;
10338         TALLOC_CTX *_mem_save_help_file_0;
10339         uint32_t _ptr_dependent_files;
10340         TALLOC_CTX *_mem_save_dependent_files_0;
10341         uint32_t _ptr_monitor_name;
10342         TALLOC_CTX *_mem_save_monitor_name_0;
10343         uint32_t _ptr_default_datatype;
10344         TALLOC_CTX *_mem_save_default_datatype_0;
10345         if (ndr_flags & NDR_SCALARS) {
10346                 NDR_CHECK(ndr_pull_align(ndr, 4));
10347                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10348                 {
10349                         uint32_t _flags_save_string = ndr->flags;
10350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10352                         if (_ptr_driver_name) {
10353                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10355                         } else {
10356                                 r->driver_name = NULL;
10357                         }
10358                         ndr->flags = _flags_save_string;
10359                 }
10360                 {
10361                         uint32_t _flags_save_string = ndr->flags;
10362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10363                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10364                         if (_ptr_architecture) {
10365                                 NDR_PULL_ALLOC(ndr, r->architecture);
10366                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10367                         } else {
10368                                 r->architecture = NULL;
10369                         }
10370                         ndr->flags = _flags_save_string;
10371                 }
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_path));
10376                         if (_ptr_driver_path) {
10377                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10379                         } else {
10380                                 r->driver_path = 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_data_file));
10388                         if (_ptr_data_file) {
10389                                 NDR_PULL_ALLOC(ndr, r->data_file);
10390                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10391                         } else {
10392                                 r->data_file = 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_config_file));
10400                         if (_ptr_config_file) {
10401                                 NDR_PULL_ALLOC(ndr, r->config_file);
10402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10403                         } else {
10404                                 r->config_file = 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_help_file));
10412                         if (_ptr_help_file) {
10413                                 NDR_PULL_ALLOC(ndr, r->help_file);
10414                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10415                         } else {
10416                                 r->help_file = NULL;
10417                         }
10418                         ndr->flags = _flags_save_string;
10419                 }
10420                 {
10421                         uint32_t _flags_save_string_array = ndr->flags;
10422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10424                         if (_ptr_dependent_files) {
10425                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10427                         } else {
10428                                 r->dependent_files = NULL;
10429                         }
10430                         ndr->flags = _flags_save_string_array;
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_monitor_name));
10436                         if (_ptr_monitor_name) {
10437                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10439                         } else {
10440                                 r->monitor_name = NULL;
10441                         }
10442                         ndr->flags = _flags_save_string;
10443                 }
10444                 {
10445                         uint32_t _flags_save_string = ndr->flags;
10446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10447                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10448                         if (_ptr_default_datatype) {
10449                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10450                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10451                         } else {
10452                                 r->default_datatype = NULL;
10453                         }
10454                         ndr->flags = _flags_save_string;
10455                 }
10456         }
10457         if (ndr_flags & NDR_BUFFERS) {
10458                 {
10459                         uint32_t _flags_save_string = ndr->flags;
10460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10461                         if (r->driver_name) {
10462                                 uint32_t _relative_save_offset;
10463                                 _relative_save_offset = ndr->offset;
10464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10465                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10466                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10469                                 ndr->offset = _relative_save_offset;
10470                         }
10471                         ndr->flags = _flags_save_string;
10472                 }
10473                 {
10474                         uint32_t _flags_save_string = ndr->flags;
10475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10476                         if (r->architecture) {
10477                                 uint32_t _relative_save_offset;
10478                                 _relative_save_offset = ndr->offset;
10479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10480                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10484                                 ndr->offset = _relative_save_offset;
10485                         }
10486                         ndr->flags = _flags_save_string;
10487                 }
10488                 {
10489                         uint32_t _flags_save_string = ndr->flags;
10490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10491                         if (r->driver_path) {
10492                                 uint32_t _relative_save_offset;
10493                                 _relative_save_offset = ndr->offset;
10494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10495                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10496                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10499                                 ndr->offset = _relative_save_offset;
10500                         }
10501                         ndr->flags = _flags_save_string;
10502                 }
10503                 {
10504                         uint32_t _flags_save_string = ndr->flags;
10505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10506                         if (r->data_file) {
10507                                 uint32_t _relative_save_offset;
10508                                 _relative_save_offset = ndr->offset;
10509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10510                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10511                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10512                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10514                                 ndr->offset = _relative_save_offset;
10515                         }
10516                         ndr->flags = _flags_save_string;
10517                 }
10518                 {
10519                         uint32_t _flags_save_string = ndr->flags;
10520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10521                         if (r->config_file) {
10522                                 uint32_t _relative_save_offset;
10523                                 _relative_save_offset = ndr->offset;
10524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10525                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10526                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10527                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10529                                 ndr->offset = _relative_save_offset;
10530                         }
10531                         ndr->flags = _flags_save_string;
10532                 }
10533                 {
10534                         uint32_t _flags_save_string = ndr->flags;
10535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10536                         if (r->help_file) {
10537                                 uint32_t _relative_save_offset;
10538                                 _relative_save_offset = ndr->offset;
10539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10540                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10541                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10542                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10543                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10544                                 ndr->offset = _relative_save_offset;
10545                         }
10546                         ndr->flags = _flags_save_string;
10547                 }
10548                 {
10549                         uint32_t _flags_save_string_array = ndr->flags;
10550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10551                         if (r->dependent_files) {
10552                                 uint32_t _relative_save_offset;
10553                                 _relative_save_offset = ndr->offset;
10554                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10555                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10556                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10557                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10558                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10559                                 ndr->offset = _relative_save_offset;
10560                         }
10561                         ndr->flags = _flags_save_string_array;
10562                 }
10563                 {
10564                         uint32_t _flags_save_string = ndr->flags;
10565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10566                         if (r->monitor_name) {
10567                                 uint32_t _relative_save_offset;
10568                                 _relative_save_offset = ndr->offset;
10569                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10570                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10571                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10572                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10573                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10574                                 ndr->offset = _relative_save_offset;
10575                         }
10576                         ndr->flags = _flags_save_string;
10577                 }
10578                 {
10579                         uint32_t _flags_save_string = ndr->flags;
10580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10581                         if (r->default_datatype) {
10582                                 uint32_t _relative_save_offset;
10583                                 _relative_save_offset = ndr->offset;
10584                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10585                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10586                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10587                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10588                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10589                                 ndr->offset = _relative_save_offset;
10590                         }
10591                         ndr->flags = _flags_save_string;
10592                 }
10593         }
10594         return NDR_ERR_SUCCESS;
10595 }
10596
10597 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10598 {
10599         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10600         ndr->depth++;
10601         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10602         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10603         ndr->depth++;
10604         if (r->driver_name) {
10605                 ndr_print_string(ndr, "driver_name", r->driver_name);
10606         }
10607         ndr->depth--;
10608         ndr_print_ptr(ndr, "architecture", r->architecture);
10609         ndr->depth++;
10610         if (r->architecture) {
10611                 ndr_print_string(ndr, "architecture", r->architecture);
10612         }
10613         ndr->depth--;
10614         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10615         ndr->depth++;
10616         if (r->driver_path) {
10617                 ndr_print_string(ndr, "driver_path", r->driver_path);
10618         }
10619         ndr->depth--;
10620         ndr_print_ptr(ndr, "data_file", r->data_file);
10621         ndr->depth++;
10622         if (r->data_file) {
10623                 ndr_print_string(ndr, "data_file", r->data_file);
10624         }
10625         ndr->depth--;
10626         ndr_print_ptr(ndr, "config_file", r->config_file);
10627         ndr->depth++;
10628         if (r->config_file) {
10629                 ndr_print_string(ndr, "config_file", r->config_file);
10630         }
10631         ndr->depth--;
10632         ndr_print_ptr(ndr, "help_file", r->help_file);
10633         ndr->depth++;
10634         if (r->help_file) {
10635                 ndr_print_string(ndr, "help_file", r->help_file);
10636         }
10637         ndr->depth--;
10638         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10639         ndr->depth++;
10640         if (r->dependent_files) {
10641                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10642         }
10643         ndr->depth--;
10644         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10645         ndr->depth++;
10646         if (r->monitor_name) {
10647                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10648         }
10649         ndr->depth--;
10650         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10651         ndr->depth++;
10652         if (r->default_datatype) {
10653                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10654         }
10655         ndr->depth--;
10656         ndr->depth--;
10657 }
10658
10659 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10660 {
10661         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10662 }
10663
10664 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10665 {
10666         if (ndr_flags & NDR_SCALARS) {
10667                 NDR_CHECK(ndr_push_align(ndr, 4));
10668                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10669                 {
10670                         uint32_t _flags_save_string = ndr->flags;
10671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10672                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10673                         ndr->flags = _flags_save_string;
10674                 }
10675                 {
10676                         uint32_t _flags_save_string = ndr->flags;
10677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10678                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10679                         ndr->flags = _flags_save_string;
10680                 }
10681                 {
10682                         uint32_t _flags_save_string = ndr->flags;
10683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10684                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10685                         ndr->flags = _flags_save_string;
10686                 }
10687                 {
10688                         uint32_t _flags_save_string = ndr->flags;
10689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10690                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10691                         ndr->flags = _flags_save_string;
10692                 }
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->config_file));
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->help_file));
10703                         ndr->flags = _flags_save_string;
10704                 }
10705                 {
10706                         uint32_t _flags_save_string_array = ndr->flags;
10707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10709                         ndr->flags = _flags_save_string_array;
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->monitor_name));
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->default_datatype));
10721                         ndr->flags = _flags_save_string;
10722                 }
10723                 {
10724                         uint32_t _flags_save_string_array = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10727                         ndr->flags = _flags_save_string_array;
10728                 }
10729         }
10730         if (ndr_flags & NDR_BUFFERS) {
10731                 {
10732                         uint32_t _flags_save_string = ndr->flags;
10733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10734                         if (r->driver_name) {
10735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10737                         }
10738                         ndr->flags = _flags_save_string;
10739                 }
10740                 {
10741                         uint32_t _flags_save_string = ndr->flags;
10742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10743                         if (r->architecture) {
10744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10745                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10746                         }
10747                         ndr->flags = _flags_save_string;
10748                 }
10749                 {
10750                         uint32_t _flags_save_string = ndr->flags;
10751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10752                         if (r->driver_path) {
10753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10755                         }
10756                         ndr->flags = _flags_save_string;
10757                 }
10758                 {
10759                         uint32_t _flags_save_string = ndr->flags;
10760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10761                         if (r->data_file) {
10762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10764                         }
10765                         ndr->flags = _flags_save_string;
10766                 }
10767                 {
10768                         uint32_t _flags_save_string = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         if (r->config_file) {
10771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10772                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10773                         }
10774                         ndr->flags = _flags_save_string;
10775                 }
10776                 {
10777                         uint32_t _flags_save_string = ndr->flags;
10778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10779                         if (r->help_file) {
10780                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10781                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10782                         }
10783                         ndr->flags = _flags_save_string;
10784                 }
10785                 {
10786                         uint32_t _flags_save_string_array = ndr->flags;
10787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10788                         if (r->dependent_files) {
10789                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10790                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10791                         }
10792                         ndr->flags = _flags_save_string_array;
10793                 }
10794                 {
10795                         uint32_t _flags_save_string = ndr->flags;
10796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10797                         if (r->monitor_name) {
10798                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10799                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10800                         }
10801                         ndr->flags = _flags_save_string;
10802                 }
10803                 {
10804                         uint32_t _flags_save_string = ndr->flags;
10805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10806                         if (r->default_datatype) {
10807                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10808                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10809                         }
10810                         ndr->flags = _flags_save_string;
10811                 }
10812                 {
10813                         uint32_t _flags_save_string_array = ndr->flags;
10814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10815                         if (r->previous_names) {
10816                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10817                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10818                         }
10819                         ndr->flags = _flags_save_string_array;
10820                 }
10821         }
10822         return NDR_ERR_SUCCESS;
10823 }
10824
10825 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10826 {
10827         uint32_t _ptr_driver_name;
10828         TALLOC_CTX *_mem_save_driver_name_0;
10829         uint32_t _ptr_architecture;
10830         TALLOC_CTX *_mem_save_architecture_0;
10831         uint32_t _ptr_driver_path;
10832         TALLOC_CTX *_mem_save_driver_path_0;
10833         uint32_t _ptr_data_file;
10834         TALLOC_CTX *_mem_save_data_file_0;
10835         uint32_t _ptr_config_file;
10836         TALLOC_CTX *_mem_save_config_file_0;
10837         uint32_t _ptr_help_file;
10838         TALLOC_CTX *_mem_save_help_file_0;
10839         uint32_t _ptr_dependent_files;
10840         TALLOC_CTX *_mem_save_dependent_files_0;
10841         uint32_t _ptr_monitor_name;
10842         TALLOC_CTX *_mem_save_monitor_name_0;
10843         uint32_t _ptr_default_datatype;
10844         TALLOC_CTX *_mem_save_default_datatype_0;
10845         uint32_t _ptr_previous_names;
10846         TALLOC_CTX *_mem_save_previous_names_0;
10847         if (ndr_flags & NDR_SCALARS) {
10848                 NDR_CHECK(ndr_pull_align(ndr, 4));
10849                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10850                 {
10851                         uint32_t _flags_save_string = ndr->flags;
10852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10854                         if (_ptr_driver_name) {
10855                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10857                         } else {
10858                                 r->driver_name = NULL;
10859                         }
10860                         ndr->flags = _flags_save_string;
10861                 }
10862                 {
10863                         uint32_t _flags_save_string = ndr->flags;
10864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10866                         if (_ptr_architecture) {
10867                                 NDR_PULL_ALLOC(ndr, r->architecture);
10868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10869                         } else {
10870                                 r->architecture = NULL;
10871                         }
10872                         ndr->flags = _flags_save_string;
10873                 }
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_path));
10878                         if (_ptr_driver_path) {
10879                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10880                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10881                         } else {
10882                                 r->driver_path = 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_data_file));
10890                         if (_ptr_data_file) {
10891                                 NDR_PULL_ALLOC(ndr, r->data_file);
10892                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10893                         } else {
10894                                 r->data_file = 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_config_file));
10902                         if (_ptr_config_file) {
10903                                 NDR_PULL_ALLOC(ndr, r->config_file);
10904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10905                         } else {
10906                                 r->config_file = 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_help_file));
10914                         if (_ptr_help_file) {
10915                                 NDR_PULL_ALLOC(ndr, r->help_file);
10916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10917                         } else {
10918                                 r->help_file = NULL;
10919                         }
10920                         ndr->flags = _flags_save_string;
10921                 }
10922                 {
10923                         uint32_t _flags_save_string_array = ndr->flags;
10924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10926                         if (_ptr_dependent_files) {
10927                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10929                         } else {
10930                                 r->dependent_files = NULL;
10931                         }
10932                         ndr->flags = _flags_save_string_array;
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_monitor_name));
10938                         if (_ptr_monitor_name) {
10939                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10940                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10941                         } else {
10942                                 r->monitor_name = NULL;
10943                         }
10944                         ndr->flags = _flags_save_string;
10945                 }
10946                 {
10947                         uint32_t _flags_save_string = ndr->flags;
10948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10950                         if (_ptr_default_datatype) {
10951                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10953                         } else {
10954                                 r->default_datatype = NULL;
10955                         }
10956                         ndr->flags = _flags_save_string;
10957                 }
10958                 {
10959                         uint32_t _flags_save_string_array = ndr->flags;
10960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10961                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10962                         if (_ptr_previous_names) {
10963                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10964                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10965                         } else {
10966                                 r->previous_names = NULL;
10967                         }
10968                         ndr->flags = _flags_save_string_array;
10969                 }
10970         }
10971         if (ndr_flags & NDR_BUFFERS) {
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         if (r->driver_name) {
10976                                 uint32_t _relative_save_offset;
10977                                 _relative_save_offset = ndr->offset;
10978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10979                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10980                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10981                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10983                                 ndr->offset = _relative_save_offset;
10984                         }
10985                         ndr->flags = _flags_save_string;
10986                 }
10987                 {
10988                         uint32_t _flags_save_string = ndr->flags;
10989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10990                         if (r->architecture) {
10991                                 uint32_t _relative_save_offset;
10992                                 _relative_save_offset = ndr->offset;
10993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10994                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10995                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10998                                 ndr->offset = _relative_save_offset;
10999                         }
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         if (r->driver_path) {
11006                                 uint32_t _relative_save_offset;
11007                                 _relative_save_offset = ndr->offset;
11008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11009                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11010                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11013                                 ndr->offset = _relative_save_offset;
11014                         }
11015                         ndr->flags = _flags_save_string;
11016                 }
11017                 {
11018                         uint32_t _flags_save_string = ndr->flags;
11019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11020                         if (r->data_file) {
11021                                 uint32_t _relative_save_offset;
11022                                 _relative_save_offset = ndr->offset;
11023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11024                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11025                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11028                                 ndr->offset = _relative_save_offset;
11029                         }
11030                         ndr->flags = _flags_save_string;
11031                 }
11032                 {
11033                         uint32_t _flags_save_string = ndr->flags;
11034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11035                         if (r->config_file) {
11036                                 uint32_t _relative_save_offset;
11037                                 _relative_save_offset = ndr->offset;
11038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11039                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11040                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11043                                 ndr->offset = _relative_save_offset;
11044                         }
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         if (r->help_file) {
11051                                 uint32_t _relative_save_offset;
11052                                 _relative_save_offset = ndr->offset;
11053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11054                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11055                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11058                                 ndr->offset = _relative_save_offset;
11059                         }
11060                         ndr->flags = _flags_save_string;
11061                 }
11062                 {
11063                         uint32_t _flags_save_string_array = ndr->flags;
11064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11065                         if (r->dependent_files) {
11066                                 uint32_t _relative_save_offset;
11067                                 _relative_save_offset = ndr->offset;
11068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11069                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11070                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11071                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11073                                 ndr->offset = _relative_save_offset;
11074                         }
11075                         ndr->flags = _flags_save_string_array;
11076                 }
11077                 {
11078                         uint32_t _flags_save_string = ndr->flags;
11079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11080                         if (r->monitor_name) {
11081                                 uint32_t _relative_save_offset;
11082                                 _relative_save_offset = ndr->offset;
11083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11084                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11085                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11086                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11088                                 ndr->offset = _relative_save_offset;
11089                         }
11090                         ndr->flags = _flags_save_string;
11091                 }
11092                 {
11093                         uint32_t _flags_save_string = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->default_datatype) {
11096                                 uint32_t _relative_save_offset;
11097                                 _relative_save_offset = ndr->offset;
11098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11099                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11100                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11103                                 ndr->offset = _relative_save_offset;
11104                         }
11105                         ndr->flags = _flags_save_string;
11106                 }
11107                 {
11108                         uint32_t _flags_save_string_array = ndr->flags;
11109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11110                         if (r->previous_names) {
11111                                 uint32_t _relative_save_offset;
11112                                 _relative_save_offset = ndr->offset;
11113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11114                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11115                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11116                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11118                                 ndr->offset = _relative_save_offset;
11119                         }
11120                         ndr->flags = _flags_save_string_array;
11121                 }
11122         }
11123         return NDR_ERR_SUCCESS;
11124 }
11125
11126 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11127 {
11128         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11129         ndr->depth++;
11130         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11131         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11132         ndr->depth++;
11133         if (r->driver_name) {
11134                 ndr_print_string(ndr, "driver_name", r->driver_name);
11135         }
11136         ndr->depth--;
11137         ndr_print_ptr(ndr, "architecture", r->architecture);
11138         ndr->depth++;
11139         if (r->architecture) {
11140                 ndr_print_string(ndr, "architecture", r->architecture);
11141         }
11142         ndr->depth--;
11143         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11144         ndr->depth++;
11145         if (r->driver_path) {
11146                 ndr_print_string(ndr, "driver_path", r->driver_path);
11147         }
11148         ndr->depth--;
11149         ndr_print_ptr(ndr, "data_file", r->data_file);
11150         ndr->depth++;
11151         if (r->data_file) {
11152                 ndr_print_string(ndr, "data_file", r->data_file);
11153         }
11154         ndr->depth--;
11155         ndr_print_ptr(ndr, "config_file", r->config_file);
11156         ndr->depth++;
11157         if (r->config_file) {
11158                 ndr_print_string(ndr, "config_file", r->config_file);
11159         }
11160         ndr->depth--;
11161         ndr_print_ptr(ndr, "help_file", r->help_file);
11162         ndr->depth++;
11163         if (r->help_file) {
11164                 ndr_print_string(ndr, "help_file", r->help_file);
11165         }
11166         ndr->depth--;
11167         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11168         ndr->depth++;
11169         if (r->dependent_files) {
11170                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11171         }
11172         ndr->depth--;
11173         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11174         ndr->depth++;
11175         if (r->monitor_name) {
11176                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11177         }
11178         ndr->depth--;
11179         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11180         ndr->depth++;
11181         if (r->default_datatype) {
11182                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11183         }
11184         ndr->depth--;
11185         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11186         ndr->depth++;
11187         if (r->previous_names) {
11188                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11189         }
11190         ndr->depth--;
11191         ndr->depth--;
11192 }
11193
11194 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11195 {
11196         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11197 }
11198
11199 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11200 {
11201         if (ndr_flags & NDR_SCALARS) {
11202                 NDR_CHECK(ndr_push_align(ndr, 4));
11203                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11204                 {
11205                         uint32_t _flags_save_string = ndr->flags;
11206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11207                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11208                         ndr->flags = _flags_save_string;
11209                 }
11210                 {
11211                         uint32_t _flags_save_string = ndr->flags;
11212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11213                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11214                         ndr->flags = _flags_save_string;
11215                 }
11216                 {
11217                         uint32_t _flags_save_string = ndr->flags;
11218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11219                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11220                         ndr->flags = _flags_save_string;
11221                 }
11222                 {
11223                         uint32_t _flags_save_string = ndr->flags;
11224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11225                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11226                         ndr->flags = _flags_save_string;
11227                 }
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->config_file));
11232                         ndr->flags = _flags_save_string;
11233                 }
11234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11237         }
11238         if (ndr_flags & NDR_BUFFERS) {
11239                 {
11240                         uint32_t _flags_save_string = ndr->flags;
11241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11242                         if (r->driver_name) {
11243                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11244                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11245                         }
11246                         ndr->flags = _flags_save_string;
11247                 }
11248                 {
11249                         uint32_t _flags_save_string = ndr->flags;
11250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11251                         if (r->architecture) {
11252                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11253                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11254                         }
11255                         ndr->flags = _flags_save_string;
11256                 }
11257                 {
11258                         uint32_t _flags_save_string = ndr->flags;
11259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11260                         if (r->driver_path) {
11261                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11262                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11263                         }
11264                         ndr->flags = _flags_save_string;
11265                 }
11266                 {
11267                         uint32_t _flags_save_string = ndr->flags;
11268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11269                         if (r->data_file) {
11270                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11271                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11272                         }
11273                         ndr->flags = _flags_save_string;
11274                 }
11275                 {
11276                         uint32_t _flags_save_string = ndr->flags;
11277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11278                         if (r->config_file) {
11279                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11280                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11281                         }
11282                         ndr->flags = _flags_save_string;
11283                 }
11284         }
11285         return NDR_ERR_SUCCESS;
11286 }
11287
11288 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11289 {
11290         uint32_t _ptr_driver_name;
11291         TALLOC_CTX *_mem_save_driver_name_0;
11292         uint32_t _ptr_architecture;
11293         TALLOC_CTX *_mem_save_architecture_0;
11294         uint32_t _ptr_driver_path;
11295         TALLOC_CTX *_mem_save_driver_path_0;
11296         uint32_t _ptr_data_file;
11297         TALLOC_CTX *_mem_save_data_file_0;
11298         uint32_t _ptr_config_file;
11299         TALLOC_CTX *_mem_save_config_file_0;
11300         if (ndr_flags & NDR_SCALARS) {
11301                 NDR_CHECK(ndr_pull_align(ndr, 4));
11302                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11303                 {
11304                         uint32_t _flags_save_string = ndr->flags;
11305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11306                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11307                         if (_ptr_driver_name) {
11308                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11309                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11310                         } else {
11311                                 r->driver_name = NULL;
11312                         }
11313                         ndr->flags = _flags_save_string;
11314                 }
11315                 {
11316                         uint32_t _flags_save_string = ndr->flags;
11317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11318                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11319                         if (_ptr_architecture) {
11320                                 NDR_PULL_ALLOC(ndr, r->architecture);
11321                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11322                         } else {
11323                                 r->architecture = NULL;
11324                         }
11325                         ndr->flags = _flags_save_string;
11326                 }
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_path));
11331                         if (_ptr_driver_path) {
11332                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11334                         } else {
11335                                 r->driver_path = 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_data_file));
11343                         if (_ptr_data_file) {
11344                                 NDR_PULL_ALLOC(ndr, r->data_file);
11345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11346                         } else {
11347                                 r->data_file = 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_config_file));
11355                         if (_ptr_config_file) {
11356                                 NDR_PULL_ALLOC(ndr, r->config_file);
11357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11358                         } else {
11359                                 r->config_file = NULL;
11360                         }
11361                         ndr->flags = _flags_save_string;
11362                 }
11363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11366         }
11367         if (ndr_flags & NDR_BUFFERS) {
11368                 {
11369                         uint32_t _flags_save_string = ndr->flags;
11370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11371                         if (r->driver_name) {
11372                                 uint32_t _relative_save_offset;
11373                                 _relative_save_offset = ndr->offset;
11374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11375                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11376                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11379                                 ndr->offset = _relative_save_offset;
11380                         }
11381                         ndr->flags = _flags_save_string;
11382                 }
11383                 {
11384                         uint32_t _flags_save_string = ndr->flags;
11385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11386                         if (r->architecture) {
11387                                 uint32_t _relative_save_offset;
11388                                 _relative_save_offset = ndr->offset;
11389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11390                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11391                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11394                                 ndr->offset = _relative_save_offset;
11395                         }
11396                         ndr->flags = _flags_save_string;
11397                 }
11398                 {
11399                         uint32_t _flags_save_string = ndr->flags;
11400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11401                         if (r->driver_path) {
11402                                 uint32_t _relative_save_offset;
11403                                 _relative_save_offset = ndr->offset;
11404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11405                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11406                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11409                                 ndr->offset = _relative_save_offset;
11410                         }
11411                         ndr->flags = _flags_save_string;
11412                 }
11413                 {
11414                         uint32_t _flags_save_string = ndr->flags;
11415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11416                         if (r->data_file) {
11417                                 uint32_t _relative_save_offset;
11418                                 _relative_save_offset = ndr->offset;
11419                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11420                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11421                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11422                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11423                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11424                                 ndr->offset = _relative_save_offset;
11425                         }
11426                         ndr->flags = _flags_save_string;
11427                 }
11428                 {
11429                         uint32_t _flags_save_string = ndr->flags;
11430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11431                         if (r->config_file) {
11432                                 uint32_t _relative_save_offset;
11433                                 _relative_save_offset = ndr->offset;
11434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11435                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11436                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11439                                 ndr->offset = _relative_save_offset;
11440                         }
11441                         ndr->flags = _flags_save_string;
11442                 }
11443         }
11444         return NDR_ERR_SUCCESS;
11445 }
11446
11447 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11448 {
11449         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11450         ndr->depth++;
11451         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11452         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11453         ndr->depth++;
11454         if (r->driver_name) {
11455                 ndr_print_string(ndr, "driver_name", r->driver_name);
11456         }
11457         ndr->depth--;
11458         ndr_print_ptr(ndr, "architecture", r->architecture);
11459         ndr->depth++;
11460         if (r->architecture) {
11461                 ndr_print_string(ndr, "architecture", r->architecture);
11462         }
11463         ndr->depth--;
11464         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11465         ndr->depth++;
11466         if (r->driver_path) {
11467                 ndr_print_string(ndr, "driver_path", r->driver_path);
11468         }
11469         ndr->depth--;
11470         ndr_print_ptr(ndr, "data_file", r->data_file);
11471         ndr->depth++;
11472         if (r->data_file) {
11473                 ndr_print_string(ndr, "data_file", r->data_file);
11474         }
11475         ndr->depth--;
11476         ndr_print_ptr(ndr, "config_file", r->config_file);
11477         ndr->depth++;
11478         if (r->config_file) {
11479                 ndr_print_string(ndr, "config_file", r->config_file);
11480         }
11481         ndr->depth--;
11482         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11483         ndr_print_uint32(ndr, "config_version", r->config_version);
11484         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11485         ndr->depth--;
11486 }
11487
11488 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11489 {
11490         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11491 }
11492
11493 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11494 {
11495         if (ndr_flags & NDR_SCALARS) {
11496                 NDR_CHECK(ndr_push_align(ndr, 8));
11497                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11498                 {
11499                         uint32_t _flags_save_string = ndr->flags;
11500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11502                         ndr->flags = _flags_save_string;
11503                 }
11504                 {
11505                         uint32_t _flags_save_string = ndr->flags;
11506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11508                         ndr->flags = _flags_save_string;
11509                 }
11510                 {
11511                         uint32_t _flags_save_string = ndr->flags;
11512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11514                         ndr->flags = _flags_save_string;
11515                 }
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11520                         ndr->flags = _flags_save_string;
11521                 }
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->config_file));
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->help_file));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string_array = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11538                         ndr->flags = _flags_save_string_array;
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->monitor_name));
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->default_datatype));
11550                         ndr->flags = _flags_save_string;
11551                 }
11552                 {
11553                         uint32_t _flags_save_string_array = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11556                         ndr->flags = _flags_save_string_array;
11557                 }
11558                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11559                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11560                 {
11561                         uint32_t _flags_save_string = ndr->flags;
11562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11563                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11564                         ndr->flags = _flags_save_string;
11565                 }
11566                 {
11567                         uint32_t _flags_save_string = ndr->flags;
11568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11570                         ndr->flags = _flags_save_string;
11571                 }
11572                 {
11573                         uint32_t _flags_save_string = ndr->flags;
11574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11576                         ndr->flags = _flags_save_string;
11577                 }
11578                 {
11579                         uint32_t _flags_save_string = ndr->flags;
11580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11582                         ndr->flags = _flags_save_string;
11583                 }
11584         }
11585         if (ndr_flags & NDR_BUFFERS) {
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         if (r->driver_name) {
11590                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11591                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11592                         }
11593                         ndr->flags = _flags_save_string;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11598                         if (r->architecture) {
11599                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11600                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11601                         }
11602                         ndr->flags = _flags_save_string;
11603                 }
11604                 {
11605                         uint32_t _flags_save_string = ndr->flags;
11606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11607                         if (r->driver_path) {
11608                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11610                         }
11611                         ndr->flags = _flags_save_string;
11612                 }
11613                 {
11614                         uint32_t _flags_save_string = ndr->flags;
11615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11616                         if (r->data_file) {
11617                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11618                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11619                         }
11620                         ndr->flags = _flags_save_string;
11621                 }
11622                 {
11623                         uint32_t _flags_save_string = ndr->flags;
11624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11625                         if (r->config_file) {
11626                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11628                         }
11629                         ndr->flags = _flags_save_string;
11630                 }
11631                 {
11632                         uint32_t _flags_save_string = ndr->flags;
11633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11634                         if (r->help_file) {
11635                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11637                         }
11638                         ndr->flags = _flags_save_string;
11639                 }
11640                 {
11641                         uint32_t _flags_save_string_array = ndr->flags;
11642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11643                         if (r->dependent_files) {
11644                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11645                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11646                         }
11647                         ndr->flags = _flags_save_string_array;
11648                 }
11649                 {
11650                         uint32_t _flags_save_string = ndr->flags;
11651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11652                         if (r->monitor_name) {
11653                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11655                         }
11656                         ndr->flags = _flags_save_string;
11657                 }
11658                 {
11659                         uint32_t _flags_save_string = ndr->flags;
11660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11661                         if (r->default_datatype) {
11662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11664                         }
11665                         ndr->flags = _flags_save_string;
11666                 }
11667                 {
11668                         uint32_t _flags_save_string_array = ndr->flags;
11669                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11670                         if (r->previous_names) {
11671                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11672                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11673                         }
11674                         ndr->flags = _flags_save_string_array;
11675                 }
11676                 {
11677                         uint32_t _flags_save_string = ndr->flags;
11678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11679                         if (r->manufacturer_name) {
11680                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11681                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11682                         }
11683                         ndr->flags = _flags_save_string;
11684                 }
11685                 {
11686                         uint32_t _flags_save_string = ndr->flags;
11687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11688                         if (r->manufacturer_url) {
11689                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11690                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11691                         }
11692                         ndr->flags = _flags_save_string;
11693                 }
11694                 {
11695                         uint32_t _flags_save_string = ndr->flags;
11696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11697                         if (r->hardware_id) {
11698                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11699                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11700                         }
11701                         ndr->flags = _flags_save_string;
11702                 }
11703                 {
11704                         uint32_t _flags_save_string = ndr->flags;
11705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11706                         if (r->provider) {
11707                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11708                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11709                         }
11710                         ndr->flags = _flags_save_string;
11711                 }
11712         }
11713         return NDR_ERR_SUCCESS;
11714 }
11715
11716 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11717 {
11718         uint32_t _ptr_driver_name;
11719         TALLOC_CTX *_mem_save_driver_name_0;
11720         uint32_t _ptr_architecture;
11721         TALLOC_CTX *_mem_save_architecture_0;
11722         uint32_t _ptr_driver_path;
11723         TALLOC_CTX *_mem_save_driver_path_0;
11724         uint32_t _ptr_data_file;
11725         TALLOC_CTX *_mem_save_data_file_0;
11726         uint32_t _ptr_config_file;
11727         TALLOC_CTX *_mem_save_config_file_0;
11728         uint32_t _ptr_help_file;
11729         TALLOC_CTX *_mem_save_help_file_0;
11730         uint32_t _ptr_dependent_files;
11731         TALLOC_CTX *_mem_save_dependent_files_0;
11732         uint32_t _ptr_monitor_name;
11733         TALLOC_CTX *_mem_save_monitor_name_0;
11734         uint32_t _ptr_default_datatype;
11735         TALLOC_CTX *_mem_save_default_datatype_0;
11736         uint32_t _ptr_previous_names;
11737         TALLOC_CTX *_mem_save_previous_names_0;
11738         uint32_t _ptr_manufacturer_name;
11739         TALLOC_CTX *_mem_save_manufacturer_name_0;
11740         uint32_t _ptr_manufacturer_url;
11741         TALLOC_CTX *_mem_save_manufacturer_url_0;
11742         uint32_t _ptr_hardware_id;
11743         TALLOC_CTX *_mem_save_hardware_id_0;
11744         uint32_t _ptr_provider;
11745         TALLOC_CTX *_mem_save_provider_0;
11746         if (ndr_flags & NDR_SCALARS) {
11747                 NDR_CHECK(ndr_pull_align(ndr, 8));
11748                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11749                 {
11750                         uint32_t _flags_save_string = ndr->flags;
11751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11753                         if (_ptr_driver_name) {
11754                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11756                         } else {
11757                                 r->driver_name = NULL;
11758                         }
11759                         ndr->flags = _flags_save_string;
11760                 }
11761                 {
11762                         uint32_t _flags_save_string = ndr->flags;
11763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11765                         if (_ptr_architecture) {
11766                                 NDR_PULL_ALLOC(ndr, r->architecture);
11767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11768                         } else {
11769                                 r->architecture = NULL;
11770                         }
11771                         ndr->flags = _flags_save_string;
11772                 }
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_path));
11777                         if (_ptr_driver_path) {
11778                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11780                         } else {
11781                                 r->driver_path = 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_data_file));
11789                         if (_ptr_data_file) {
11790                                 NDR_PULL_ALLOC(ndr, r->data_file);
11791                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11792                         } else {
11793                                 r->data_file = 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_config_file));
11801                         if (_ptr_config_file) {
11802                                 NDR_PULL_ALLOC(ndr, r->config_file);
11803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11804                         } else {
11805                                 r->config_file = 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_help_file));
11813                         if (_ptr_help_file) {
11814                                 NDR_PULL_ALLOC(ndr, r->help_file);
11815                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11816                         } else {
11817                                 r->help_file = NULL;
11818                         }
11819                         ndr->flags = _flags_save_string;
11820                 }
11821                 {
11822                         uint32_t _flags_save_string_array = ndr->flags;
11823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11825                         if (_ptr_dependent_files) {
11826                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11828                         } else {
11829                                 r->dependent_files = NULL;
11830                         }
11831                         ndr->flags = _flags_save_string_array;
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_monitor_name));
11837                         if (_ptr_monitor_name) {
11838                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11840                         } else {
11841                                 r->monitor_name = NULL;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11849                         if (_ptr_default_datatype) {
11850                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11852                         } else {
11853                                 r->default_datatype = NULL;
11854                         }
11855                         ndr->flags = _flags_save_string;
11856                 }
11857                 {
11858                         uint32_t _flags_save_string_array = ndr->flags;
11859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11861                         if (_ptr_previous_names) {
11862                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11864                         } else {
11865                                 r->previous_names = NULL;
11866                         }
11867                         ndr->flags = _flags_save_string_array;
11868                 }
11869                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11870                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11871                 {
11872                         uint32_t _flags_save_string = ndr->flags;
11873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11875                         if (_ptr_manufacturer_name) {
11876                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11878                         } else {
11879                                 r->manufacturer_name = NULL;
11880                         }
11881                         ndr->flags = _flags_save_string;
11882                 }
11883                 {
11884                         uint32_t _flags_save_string = ndr->flags;
11885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11887                         if (_ptr_manufacturer_url) {
11888                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11890                         } else {
11891                                 r->manufacturer_url = NULL;
11892                         }
11893                         ndr->flags = _flags_save_string;
11894                 }
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_hardware_id));
11899                         if (_ptr_hardware_id) {
11900                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11901                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11902                         } else {
11903                                 r->hardware_id = 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_provider));
11911                         if (_ptr_provider) {
11912                                 NDR_PULL_ALLOC(ndr, r->provider);
11913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11914                         } else {
11915                                 r->provider = NULL;
11916                         }
11917                         ndr->flags = _flags_save_string;
11918                 }
11919         }
11920         if (ndr_flags & NDR_BUFFERS) {
11921                 {
11922                         uint32_t _flags_save_string = ndr->flags;
11923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11924                         if (r->driver_name) {
11925                                 uint32_t _relative_save_offset;
11926                                 _relative_save_offset = ndr->offset;
11927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11928                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11929                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11932                                 ndr->offset = _relative_save_offset;
11933                         }
11934                         ndr->flags = _flags_save_string;
11935                 }
11936                 {
11937                         uint32_t _flags_save_string = ndr->flags;
11938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11939                         if (r->architecture) {
11940                                 uint32_t _relative_save_offset;
11941                                 _relative_save_offset = ndr->offset;
11942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11943                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11944                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11947                                 ndr->offset = _relative_save_offset;
11948                         }
11949                         ndr->flags = _flags_save_string;
11950                 }
11951                 {
11952                         uint32_t _flags_save_string = ndr->flags;
11953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11954                         if (r->driver_path) {
11955                                 uint32_t _relative_save_offset;
11956                                 _relative_save_offset = ndr->offset;
11957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11958                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11959                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11962                                 ndr->offset = _relative_save_offset;
11963                         }
11964                         ndr->flags = _flags_save_string;
11965                 }
11966                 {
11967                         uint32_t _flags_save_string = ndr->flags;
11968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11969                         if (r->data_file) {
11970                                 uint32_t _relative_save_offset;
11971                                 _relative_save_offset = ndr->offset;
11972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11973                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11974                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11977                                 ndr->offset = _relative_save_offset;
11978                         }
11979                         ndr->flags = _flags_save_string;
11980                 }
11981                 {
11982                         uint32_t _flags_save_string = ndr->flags;
11983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11984                         if (r->config_file) {
11985                                 uint32_t _relative_save_offset;
11986                                 _relative_save_offset = ndr->offset;
11987                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11988                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11990                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11991                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11992                                 ndr->offset = _relative_save_offset;
11993                         }
11994                         ndr->flags = _flags_save_string;
11995                 }
11996                 {
11997                         uint32_t _flags_save_string = ndr->flags;
11998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11999                         if (r->help_file) {
12000                                 uint32_t _relative_save_offset;
12001                                 _relative_save_offset = ndr->offset;
12002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12003                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12004                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12007                                 ndr->offset = _relative_save_offset;
12008                         }
12009                         ndr->flags = _flags_save_string;
12010                 }
12011                 {
12012                         uint32_t _flags_save_string_array = ndr->flags;
12013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12014                         if (r->dependent_files) {
12015                                 uint32_t _relative_save_offset;
12016                                 _relative_save_offset = ndr->offset;
12017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12018                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12019                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12020                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12022                                 ndr->offset = _relative_save_offset;
12023                         }
12024                         ndr->flags = _flags_save_string_array;
12025                 }
12026                 {
12027                         uint32_t _flags_save_string = ndr->flags;
12028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12029                         if (r->monitor_name) {
12030                                 uint32_t _relative_save_offset;
12031                                 _relative_save_offset = ndr->offset;
12032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12033                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12034                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12037                                 ndr->offset = _relative_save_offset;
12038                         }
12039                         ndr->flags = _flags_save_string;
12040                 }
12041                 {
12042                         uint32_t _flags_save_string = ndr->flags;
12043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12044                         if (r->default_datatype) {
12045                                 uint32_t _relative_save_offset;
12046                                 _relative_save_offset = ndr->offset;
12047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12048                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12049                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12052                                 ndr->offset = _relative_save_offset;
12053                         }
12054                         ndr->flags = _flags_save_string;
12055                 }
12056                 {
12057                         uint32_t _flags_save_string_array = ndr->flags;
12058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12059                         if (r->previous_names) {
12060                                 uint32_t _relative_save_offset;
12061                                 _relative_save_offset = ndr->offset;
12062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12063                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12064                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12065                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12067                                 ndr->offset = _relative_save_offset;
12068                         }
12069                         ndr->flags = _flags_save_string_array;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         if (r->manufacturer_name) {
12075                                 uint32_t _relative_save_offset;
12076                                 _relative_save_offset = ndr->offset;
12077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12078                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12079                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12082                                 ndr->offset = _relative_save_offset;
12083                         }
12084                         ndr->flags = _flags_save_string;
12085                 }
12086                 {
12087                         uint32_t _flags_save_string = ndr->flags;
12088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12089                         if (r->manufacturer_url) {
12090                                 uint32_t _relative_save_offset;
12091                                 _relative_save_offset = ndr->offset;
12092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12093                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12094                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12095                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12097                                 ndr->offset = _relative_save_offset;
12098                         }
12099                         ndr->flags = _flags_save_string;
12100                 }
12101                 {
12102                         uint32_t _flags_save_string = ndr->flags;
12103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12104                         if (r->hardware_id) {
12105                                 uint32_t _relative_save_offset;
12106                                 _relative_save_offset = ndr->offset;
12107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12108                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12109                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12112                                 ndr->offset = _relative_save_offset;
12113                         }
12114                         ndr->flags = _flags_save_string;
12115                 }
12116                 {
12117                         uint32_t _flags_save_string = ndr->flags;
12118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12119                         if (r->provider) {
12120                                 uint32_t _relative_save_offset;
12121                                 _relative_save_offset = ndr->offset;
12122                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12123                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12124                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12125                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12126                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12127                                 ndr->offset = _relative_save_offset;
12128                         }
12129                         ndr->flags = _flags_save_string;
12130                 }
12131         }
12132         return NDR_ERR_SUCCESS;
12133 }
12134
12135 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12136 {
12137         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12138         ndr->depth++;
12139         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12140         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12141         ndr->depth++;
12142         if (r->driver_name) {
12143                 ndr_print_string(ndr, "driver_name", r->driver_name);
12144         }
12145         ndr->depth--;
12146         ndr_print_ptr(ndr, "architecture", r->architecture);
12147         ndr->depth++;
12148         if (r->architecture) {
12149                 ndr_print_string(ndr, "architecture", r->architecture);
12150         }
12151         ndr->depth--;
12152         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12153         ndr->depth++;
12154         if (r->driver_path) {
12155                 ndr_print_string(ndr, "driver_path", r->driver_path);
12156         }
12157         ndr->depth--;
12158         ndr_print_ptr(ndr, "data_file", r->data_file);
12159         ndr->depth++;
12160         if (r->data_file) {
12161                 ndr_print_string(ndr, "data_file", r->data_file);
12162         }
12163         ndr->depth--;
12164         ndr_print_ptr(ndr, "config_file", r->config_file);
12165         ndr->depth++;
12166         if (r->config_file) {
12167                 ndr_print_string(ndr, "config_file", r->config_file);
12168         }
12169         ndr->depth--;
12170         ndr_print_ptr(ndr, "help_file", r->help_file);
12171         ndr->depth++;
12172         if (r->help_file) {
12173                 ndr_print_string(ndr, "help_file", r->help_file);
12174         }
12175         ndr->depth--;
12176         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12177         ndr->depth++;
12178         if (r->dependent_files) {
12179                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12180         }
12181         ndr->depth--;
12182         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12183         ndr->depth++;
12184         if (r->monitor_name) {
12185                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12186         }
12187         ndr->depth--;
12188         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12189         ndr->depth++;
12190         if (r->default_datatype) {
12191                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12192         }
12193         ndr->depth--;
12194         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12195         ndr->depth++;
12196         if (r->previous_names) {
12197                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12198         }
12199         ndr->depth--;
12200         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12201         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12202         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12203         ndr->depth++;
12204         if (r->manufacturer_name) {
12205                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12206         }
12207         ndr->depth--;
12208         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12209         ndr->depth++;
12210         if (r->manufacturer_url) {
12211                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12212         }
12213         ndr->depth--;
12214         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12215         ndr->depth++;
12216         if (r->hardware_id) {
12217                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12218         }
12219         ndr->depth--;
12220         ndr_print_ptr(ndr, "provider", r->provider);
12221         ndr->depth++;
12222         if (r->provider) {
12223                 ndr_print_string(ndr, "provider", r->provider);
12224         }
12225         ndr->depth--;
12226         ndr->depth--;
12227 }
12228
12229 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12230 {
12231         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12232 }
12233
12234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12235 {
12236         if (ndr_flags & NDR_SCALARS) {
12237                 NDR_CHECK(ndr_push_align(ndr, 8));
12238                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12239                 {
12240                         uint32_t _flags_save_string = ndr->flags;
12241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12243                         ndr->flags = _flags_save_string;
12244                 }
12245                 {
12246                         uint32_t _flags_save_string = ndr->flags;
12247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12249                         ndr->flags = _flags_save_string;
12250                 }
12251                 {
12252                         uint32_t _flags_save_string = ndr->flags;
12253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12255                         ndr->flags = _flags_save_string;
12256                 }
12257                 {
12258                         uint32_t _flags_save_string = ndr->flags;
12259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12261                         ndr->flags = _flags_save_string;
12262                 }
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->config_file));
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->help_file));
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->monitor_name));
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->default_datatype));
12285                         ndr->flags = _flags_save_string;
12286                 }
12287                 {
12288                         uint32_t _flags_save_string_array = ndr->flags;
12289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12290                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12291                         ndr->flags = _flags_save_string_array;
12292                 }
12293                 {
12294                         uint32_t _flags_save_string_array = ndr->flags;
12295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12297                         ndr->flags = _flags_save_string_array;
12298                 }
12299                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12300                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12301                 {
12302                         uint32_t _flags_save_string = ndr->flags;
12303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12304                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12305                         ndr->flags = _flags_save_string;
12306                 }
12307                 {
12308                         uint32_t _flags_save_string = ndr->flags;
12309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12310                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12311                         ndr->flags = _flags_save_string;
12312                 }
12313                 {
12314                         uint32_t _flags_save_string = ndr->flags;
12315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12316                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12317                         ndr->flags = _flags_save_string;
12318                 }
12319                 {
12320                         uint32_t _flags_save_string = ndr->flags;
12321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12322                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12323                         ndr->flags = _flags_save_string;
12324                 }
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->print_processor));
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->vendor_setup));
12335                         ndr->flags = _flags_save_string;
12336                 }
12337                 {
12338                         uint32_t _flags_save_string_array = ndr->flags;
12339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12340                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12341                         ndr->flags = _flags_save_string_array;
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->inf_path));
12347                         ndr->flags = _flags_save_string;
12348                 }
12349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12350                 {
12351                         uint32_t _flags_save_string_array = ndr->flags;
12352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12353                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12354                         ndr->flags = _flags_save_string_array;
12355                 }
12356                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12357                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12358         }
12359         if (ndr_flags & NDR_BUFFERS) {
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         if (r->driver_name) {
12364                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12365                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12366                         }
12367                         ndr->flags = _flags_save_string;
12368                 }
12369                 {
12370                         uint32_t _flags_save_string = ndr->flags;
12371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12372                         if (r->architecture) {
12373                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12374                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12375                         }
12376                         ndr->flags = _flags_save_string;
12377                 }
12378                 {
12379                         uint32_t _flags_save_string = ndr->flags;
12380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12381                         if (r->driver_path) {
12382                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12383                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12384                         }
12385                         ndr->flags = _flags_save_string;
12386                 }
12387                 {
12388                         uint32_t _flags_save_string = ndr->flags;
12389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12390                         if (r->data_file) {
12391                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12392                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12393                         }
12394                         ndr->flags = _flags_save_string;
12395                 }
12396                 {
12397                         uint32_t _flags_save_string = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         if (r->config_file) {
12400                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12401                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12402                         }
12403                         ndr->flags = _flags_save_string;
12404                 }
12405                 {
12406                         uint32_t _flags_save_string = ndr->flags;
12407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12408                         if (r->help_file) {
12409                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12410                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12411                         }
12412                         ndr->flags = _flags_save_string;
12413                 }
12414                 {
12415                         uint32_t _flags_save_string = ndr->flags;
12416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12417                         if (r->monitor_name) {
12418                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12419                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12420                         }
12421                         ndr->flags = _flags_save_string;
12422                 }
12423                 {
12424                         uint32_t _flags_save_string = ndr->flags;
12425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12426                         if (r->default_datatype) {
12427                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12428                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12429                         }
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string_array = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         if (r->dependent_files) {
12436                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12437                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12438                         }
12439                         ndr->flags = _flags_save_string_array;
12440                 }
12441                 {
12442                         uint32_t _flags_save_string_array = ndr->flags;
12443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12444                         if (r->previous_names) {
12445                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12446                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12447                         }
12448                         ndr->flags = _flags_save_string_array;
12449                 }
12450                 {
12451                         uint32_t _flags_save_string = ndr->flags;
12452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12453                         if (r->manufacturer_name) {
12454                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12455                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12456                         }
12457                         ndr->flags = _flags_save_string;
12458                 }
12459                 {
12460                         uint32_t _flags_save_string = ndr->flags;
12461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12462                         if (r->manufacturer_url) {
12463                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12464                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12465                         }
12466                         ndr->flags = _flags_save_string;
12467                 }
12468                 {
12469                         uint32_t _flags_save_string = ndr->flags;
12470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12471                         if (r->hardware_id) {
12472                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12473                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12474                         }
12475                         ndr->flags = _flags_save_string;
12476                 }
12477                 {
12478                         uint32_t _flags_save_string = ndr->flags;
12479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12480                         if (r->provider) {
12481                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12482                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12483                         }
12484                         ndr->flags = _flags_save_string;
12485                 }
12486                 {
12487                         uint32_t _flags_save_string = ndr->flags;
12488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12489                         if (r->print_processor) {
12490                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12491                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12492                         }
12493                         ndr->flags = _flags_save_string;
12494                 }
12495                 {
12496                         uint32_t _flags_save_string = ndr->flags;
12497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12498                         if (r->vendor_setup) {
12499                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12500                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12501                         }
12502                         ndr->flags = _flags_save_string;
12503                 }
12504                 {
12505                         uint32_t _flags_save_string_array = ndr->flags;
12506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12507                         if (r->color_profiles) {
12508                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12509                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12510                         }
12511                         ndr->flags = _flags_save_string_array;
12512                 }
12513                 {
12514                         uint32_t _flags_save_string = ndr->flags;
12515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12516                         if (r->inf_path) {
12517                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12518                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12519                         }
12520                         ndr->flags = _flags_save_string;
12521                 }
12522                 {
12523                         uint32_t _flags_save_string_array = ndr->flags;
12524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12525                         if (r->core_driver_dependencies) {
12526                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12527                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12528                         }
12529                         ndr->flags = _flags_save_string_array;
12530                 }
12531         }
12532         return NDR_ERR_SUCCESS;
12533 }
12534
12535 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12536 {
12537         uint32_t _ptr_driver_name;
12538         TALLOC_CTX *_mem_save_driver_name_0;
12539         uint32_t _ptr_architecture;
12540         TALLOC_CTX *_mem_save_architecture_0;
12541         uint32_t _ptr_driver_path;
12542         TALLOC_CTX *_mem_save_driver_path_0;
12543         uint32_t _ptr_data_file;
12544         TALLOC_CTX *_mem_save_data_file_0;
12545         uint32_t _ptr_config_file;
12546         TALLOC_CTX *_mem_save_config_file_0;
12547         uint32_t _ptr_help_file;
12548         TALLOC_CTX *_mem_save_help_file_0;
12549         uint32_t _ptr_monitor_name;
12550         TALLOC_CTX *_mem_save_monitor_name_0;
12551         uint32_t _ptr_default_datatype;
12552         TALLOC_CTX *_mem_save_default_datatype_0;
12553         uint32_t _ptr_dependent_files;
12554         TALLOC_CTX *_mem_save_dependent_files_0;
12555         uint32_t _ptr_previous_names;
12556         TALLOC_CTX *_mem_save_previous_names_0;
12557         uint32_t _ptr_manufacturer_name;
12558         TALLOC_CTX *_mem_save_manufacturer_name_0;
12559         uint32_t _ptr_manufacturer_url;
12560         TALLOC_CTX *_mem_save_manufacturer_url_0;
12561         uint32_t _ptr_hardware_id;
12562         TALLOC_CTX *_mem_save_hardware_id_0;
12563         uint32_t _ptr_provider;
12564         TALLOC_CTX *_mem_save_provider_0;
12565         uint32_t _ptr_print_processor;
12566         TALLOC_CTX *_mem_save_print_processor_0;
12567         uint32_t _ptr_vendor_setup;
12568         TALLOC_CTX *_mem_save_vendor_setup_0;
12569         uint32_t _ptr_color_profiles;
12570         TALLOC_CTX *_mem_save_color_profiles_0;
12571         uint32_t _ptr_inf_path;
12572         TALLOC_CTX *_mem_save_inf_path_0;
12573         uint32_t _ptr_core_driver_dependencies;
12574         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12575         if (ndr_flags & NDR_SCALARS) {
12576                 NDR_CHECK(ndr_pull_align(ndr, 8));
12577                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12578                 {
12579                         uint32_t _flags_save_string = ndr->flags;
12580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12581                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12582                         if (_ptr_driver_name) {
12583                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12584                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12585                         } else {
12586                                 r->driver_name = NULL;
12587                         }
12588                         ndr->flags = _flags_save_string;
12589                 }
12590                 {
12591                         uint32_t _flags_save_string = ndr->flags;
12592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12593                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12594                         if (_ptr_architecture) {
12595                                 NDR_PULL_ALLOC(ndr, r->architecture);
12596                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12597                         } else {
12598                                 r->architecture = NULL;
12599                         }
12600                         ndr->flags = _flags_save_string;
12601                 }
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_path));
12606                         if (_ptr_driver_path) {
12607                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12608                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12609                         } else {
12610                                 r->driver_path = 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_data_file));
12618                         if (_ptr_data_file) {
12619                                 NDR_PULL_ALLOC(ndr, r->data_file);
12620                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12621                         } else {
12622                                 r->data_file = 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_config_file));
12630                         if (_ptr_config_file) {
12631                                 NDR_PULL_ALLOC(ndr, r->config_file);
12632                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12633                         } else {
12634                                 r->config_file = 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_help_file));
12642                         if (_ptr_help_file) {
12643                                 NDR_PULL_ALLOC(ndr, r->help_file);
12644                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12645                         } else {
12646                                 r->help_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_monitor_name));
12654                         if (_ptr_monitor_name) {
12655                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12656                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12657                         } else {
12658                                 r->monitor_name = 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_default_datatype));
12666                         if (_ptr_default_datatype) {
12667                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12668                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12669                         } else {
12670                                 r->default_datatype = NULL;
12671                         }
12672                         ndr->flags = _flags_save_string;
12673                 }
12674                 {
12675                         uint32_t _flags_save_string_array = ndr->flags;
12676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12677                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12678                         if (_ptr_dependent_files) {
12679                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12680                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12681                         } else {
12682                                 r->dependent_files = NULL;
12683                         }
12684                         ndr->flags = _flags_save_string_array;
12685                 }
12686                 {
12687                         uint32_t _flags_save_string_array = ndr->flags;
12688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12689                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12690                         if (_ptr_previous_names) {
12691                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12692                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12693                         } else {
12694                                 r->previous_names = NULL;
12695                         }
12696                         ndr->flags = _flags_save_string_array;
12697                 }
12698                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12699                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12700                 {
12701                         uint32_t _flags_save_string = ndr->flags;
12702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12704                         if (_ptr_manufacturer_name) {
12705                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12707                         } else {
12708                                 r->manufacturer_name = NULL;
12709                         }
12710                         ndr->flags = _flags_save_string;
12711                 }
12712                 {
12713                         uint32_t _flags_save_string = ndr->flags;
12714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12716                         if (_ptr_manufacturer_url) {
12717                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12719                         } else {
12720                                 r->manufacturer_url = NULL;
12721                         }
12722                         ndr->flags = _flags_save_string;
12723                 }
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_hardware_id));
12728                         if (_ptr_hardware_id) {
12729                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12731                         } else {
12732                                 r->hardware_id = 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_provider));
12740                         if (_ptr_provider) {
12741                                 NDR_PULL_ALLOC(ndr, r->provider);
12742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12743                         } else {
12744                                 r->provider = 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_print_processor));
12752                         if (_ptr_print_processor) {
12753                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12755                         } else {
12756                                 r->print_processor = 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_vendor_setup));
12764                         if (_ptr_vendor_setup) {
12765                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12767                         } else {
12768                                 r->vendor_setup = NULL;
12769                         }
12770                         ndr->flags = _flags_save_string;
12771                 }
12772                 {
12773                         uint32_t _flags_save_string_array = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12776                         if (_ptr_color_profiles) {
12777                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12779                         } else {
12780                                 r->color_profiles = NULL;
12781                         }
12782                         ndr->flags = _flags_save_string_array;
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_inf_path));
12788                         if (_ptr_inf_path) {
12789                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12791                         } else {
12792                                 r->inf_path = NULL;
12793                         }
12794                         ndr->flags = _flags_save_string;
12795                 }
12796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12797                 {
12798                         uint32_t _flags_save_string_array = ndr->flags;
12799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12801                         if (_ptr_core_driver_dependencies) {
12802                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12804                         } else {
12805                                 r->core_driver_dependencies = NULL;
12806                         }
12807                         ndr->flags = _flags_save_string_array;
12808                 }
12809                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12810                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12811         }
12812         if (ndr_flags & NDR_BUFFERS) {
12813                 {
12814                         uint32_t _flags_save_string = ndr->flags;
12815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12816                         if (r->driver_name) {
12817                                 uint32_t _relative_save_offset;
12818                                 _relative_save_offset = ndr->offset;
12819                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12820                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12821                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12822                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12823                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12824                                 ndr->offset = _relative_save_offset;
12825                         }
12826                         ndr->flags = _flags_save_string;
12827                 }
12828                 {
12829                         uint32_t _flags_save_string = ndr->flags;
12830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12831                         if (r->architecture) {
12832                                 uint32_t _relative_save_offset;
12833                                 _relative_save_offset = ndr->offset;
12834                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12835                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12836                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12837                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12838                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12839                                 ndr->offset = _relative_save_offset;
12840                         }
12841                         ndr->flags = _flags_save_string;
12842                 }
12843                 {
12844                         uint32_t _flags_save_string = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         if (r->driver_path) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12850                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12854                                 ndr->offset = _relative_save_offset;
12855                         }
12856                         ndr->flags = _flags_save_string;
12857                 }
12858                 {
12859                         uint32_t _flags_save_string = ndr->flags;
12860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12861                         if (r->data_file) {
12862                                 uint32_t _relative_save_offset;
12863                                 _relative_save_offset = ndr->offset;
12864                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12865                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12866                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12867                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12868                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12869                                 ndr->offset = _relative_save_offset;
12870                         }
12871                         ndr->flags = _flags_save_string;
12872                 }
12873                 {
12874                         uint32_t _flags_save_string = ndr->flags;
12875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12876                         if (r->config_file) {
12877                                 uint32_t _relative_save_offset;
12878                                 _relative_save_offset = ndr->offset;
12879                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12880                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12881                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12882                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12883                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12884                                 ndr->offset = _relative_save_offset;
12885                         }
12886                         ndr->flags = _flags_save_string;
12887                 }
12888                 {
12889                         uint32_t _flags_save_string = ndr->flags;
12890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12891                         if (r->help_file) {
12892                                 uint32_t _relative_save_offset;
12893                                 _relative_save_offset = ndr->offset;
12894                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12895                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12896                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12897                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12898                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12899                                 ndr->offset = _relative_save_offset;
12900                         }
12901                         ndr->flags = _flags_save_string;
12902                 }
12903                 {
12904                         uint32_t _flags_save_string = ndr->flags;
12905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12906                         if (r->monitor_name) {
12907                                 uint32_t _relative_save_offset;
12908                                 _relative_save_offset = ndr->offset;
12909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12910                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12911                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12912                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12914                                 ndr->offset = _relative_save_offset;
12915                         }
12916                         ndr->flags = _flags_save_string;
12917                 }
12918                 {
12919                         uint32_t _flags_save_string = ndr->flags;
12920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12921                         if (r->default_datatype) {
12922                                 uint32_t _relative_save_offset;
12923                                 _relative_save_offset = ndr->offset;
12924                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12925                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12926                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12927                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12928                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string_array = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->dependent_files) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12940                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12942                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12944                                 ndr->offset = _relative_save_offset;
12945                         }
12946                         ndr->flags = _flags_save_string_array;
12947                 }
12948                 {
12949                         uint32_t _flags_save_string_array = ndr->flags;
12950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12951                         if (r->previous_names) {
12952                                 uint32_t _relative_save_offset;
12953                                 _relative_save_offset = ndr->offset;
12954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12955                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12956                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12957                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12959                                 ndr->offset = _relative_save_offset;
12960                         }
12961                         ndr->flags = _flags_save_string_array;
12962                 }
12963                 {
12964                         uint32_t _flags_save_string = ndr->flags;
12965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12966                         if (r->manufacturer_name) {
12967                                 uint32_t _relative_save_offset;
12968                                 _relative_save_offset = ndr->offset;
12969                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12970                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12971                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12972                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12973                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12974                                 ndr->offset = _relative_save_offset;
12975                         }
12976                         ndr->flags = _flags_save_string;
12977                 }
12978                 {
12979                         uint32_t _flags_save_string = ndr->flags;
12980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12981                         if (r->manufacturer_url) {
12982                                 uint32_t _relative_save_offset;
12983                                 _relative_save_offset = ndr->offset;
12984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12985                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12986                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12989                                 ndr->offset = _relative_save_offset;
12990                         }
12991                         ndr->flags = _flags_save_string;
12992                 }
12993                 {
12994                         uint32_t _flags_save_string = ndr->flags;
12995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12996                         if (r->hardware_id) {
12997                                 uint32_t _relative_save_offset;
12998                                 _relative_save_offset = ndr->offset;
12999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13000                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13001                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13002                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13004                                 ndr->offset = _relative_save_offset;
13005                         }
13006                         ndr->flags = _flags_save_string;
13007                 }
13008                 {
13009                         uint32_t _flags_save_string = ndr->flags;
13010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13011                         if (r->provider) {
13012                                 uint32_t _relative_save_offset;
13013                                 _relative_save_offset = ndr->offset;
13014                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13015                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13016                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13017                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13018                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->print_processor) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13030                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13034                                 ndr->offset = _relative_save_offset;
13035                         }
13036                         ndr->flags = _flags_save_string;
13037                 }
13038                 {
13039                         uint32_t _flags_save_string = ndr->flags;
13040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13041                         if (r->vendor_setup) {
13042                                 uint32_t _relative_save_offset;
13043                                 _relative_save_offset = ndr->offset;
13044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13045                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13046                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13049                                 ndr->offset = _relative_save_offset;
13050                         }
13051                         ndr->flags = _flags_save_string;
13052                 }
13053                 {
13054                         uint32_t _flags_save_string_array = ndr->flags;
13055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13056                         if (r->color_profiles) {
13057                                 uint32_t _relative_save_offset;
13058                                 _relative_save_offset = ndr->offset;
13059                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13060                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13061                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13062                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13063                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13064                                 ndr->offset = _relative_save_offset;
13065                         }
13066                         ndr->flags = _flags_save_string_array;
13067                 }
13068                 {
13069                         uint32_t _flags_save_string = ndr->flags;
13070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13071                         if (r->inf_path) {
13072                                 uint32_t _relative_save_offset;
13073                                 _relative_save_offset = ndr->offset;
13074                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13075                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13076                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13077                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13078                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13079                                 ndr->offset = _relative_save_offset;
13080                         }
13081                         ndr->flags = _flags_save_string;
13082                 }
13083                 {
13084                         uint32_t _flags_save_string_array = ndr->flags;
13085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13086                         if (r->core_driver_dependencies) {
13087                                 uint32_t _relative_save_offset;
13088                                 _relative_save_offset = ndr->offset;
13089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13090                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13091                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13092                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13094                                 ndr->offset = _relative_save_offset;
13095                         }
13096                         ndr->flags = _flags_save_string_array;
13097                 }
13098         }
13099         return NDR_ERR_SUCCESS;
13100 }
13101
13102 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13103 {
13104         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13105         ndr->depth++;
13106         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13107         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13108         ndr->depth++;
13109         if (r->driver_name) {
13110                 ndr_print_string(ndr, "driver_name", r->driver_name);
13111         }
13112         ndr->depth--;
13113         ndr_print_ptr(ndr, "architecture", r->architecture);
13114         ndr->depth++;
13115         if (r->architecture) {
13116                 ndr_print_string(ndr, "architecture", r->architecture);
13117         }
13118         ndr->depth--;
13119         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13120         ndr->depth++;
13121         if (r->driver_path) {
13122                 ndr_print_string(ndr, "driver_path", r->driver_path);
13123         }
13124         ndr->depth--;
13125         ndr_print_ptr(ndr, "data_file", r->data_file);
13126         ndr->depth++;
13127         if (r->data_file) {
13128                 ndr_print_string(ndr, "data_file", r->data_file);
13129         }
13130         ndr->depth--;
13131         ndr_print_ptr(ndr, "config_file", r->config_file);
13132         ndr->depth++;
13133         if (r->config_file) {
13134                 ndr_print_string(ndr, "config_file", r->config_file);
13135         }
13136         ndr->depth--;
13137         ndr_print_ptr(ndr, "help_file", r->help_file);
13138         ndr->depth++;
13139         if (r->help_file) {
13140                 ndr_print_string(ndr, "help_file", r->help_file);
13141         }
13142         ndr->depth--;
13143         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13144         ndr->depth++;
13145         if (r->monitor_name) {
13146                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13147         }
13148         ndr->depth--;
13149         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13150         ndr->depth++;
13151         if (r->default_datatype) {
13152                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13153         }
13154         ndr->depth--;
13155         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13156         ndr->depth++;
13157         if (r->dependent_files) {
13158                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13159         }
13160         ndr->depth--;
13161         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13162         ndr->depth++;
13163         if (r->previous_names) {
13164                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13165         }
13166         ndr->depth--;
13167         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13168         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13169         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13170         ndr->depth++;
13171         if (r->manufacturer_name) {
13172                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13173         }
13174         ndr->depth--;
13175         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13176         ndr->depth++;
13177         if (r->manufacturer_url) {
13178                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13179         }
13180         ndr->depth--;
13181         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13182         ndr->depth++;
13183         if (r->hardware_id) {
13184                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13185         }
13186         ndr->depth--;
13187         ndr_print_ptr(ndr, "provider", r->provider);
13188         ndr->depth++;
13189         if (r->provider) {
13190                 ndr_print_string(ndr, "provider", r->provider);
13191         }
13192         ndr->depth--;
13193         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13194         ndr->depth++;
13195         if (r->print_processor) {
13196                 ndr_print_string(ndr, "print_processor", r->print_processor);
13197         }
13198         ndr->depth--;
13199         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13200         ndr->depth++;
13201         if (r->vendor_setup) {
13202                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13203         }
13204         ndr->depth--;
13205         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13206         ndr->depth++;
13207         if (r->color_profiles) {
13208                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13209         }
13210         ndr->depth--;
13211         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13212         ndr->depth++;
13213         if (r->inf_path) {
13214                 ndr_print_string(ndr, "inf_path", r->inf_path);
13215         }
13216         ndr->depth--;
13217         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13218         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13219         ndr->depth++;
13220         if (r->core_driver_dependencies) {
13221                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13222         }
13223         ndr->depth--;
13224         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13225         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13226         ndr->depth--;
13227 }
13228
13229 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13230 {
13231         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13232 }
13233
13234 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13235 {
13236         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13237         return NDR_ERR_SUCCESS;
13238 }
13239
13240 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13241 {
13242         uint32_t v;
13243         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13244         *r = v;
13245         return NDR_ERR_SUCCESS;
13246 }
13247
13248 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13249 {
13250         const char *val = NULL;
13251
13252         switch (r) {
13253                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13254                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13255                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13256                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13257                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13258         }
13259         ndr_print_enum(ndr, name, "ENUM", val, r);
13260 }
13261
13262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13263 {
13264         if (ndr_flags & NDR_SCALARS) {
13265                 NDR_CHECK(ndr_push_align(ndr, 4));
13266                 {
13267                         uint32_t _flags_save_string = ndr->flags;
13268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13269                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13270                         ndr->flags = _flags_save_string;
13271                 }
13272                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13274         }
13275         if (ndr_flags & NDR_BUFFERS) {
13276                 {
13277                         uint32_t _flags_save_string = ndr->flags;
13278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13279                         if (r->file_name) {
13280                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13281                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13282                         }
13283                         ndr->flags = _flags_save_string;
13284                 }
13285         }
13286         return NDR_ERR_SUCCESS;
13287 }
13288
13289 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13290 {
13291         uint32_t _ptr_file_name;
13292         TALLOC_CTX *_mem_save_file_name_0;
13293         if (ndr_flags & NDR_SCALARS) {
13294                 NDR_CHECK(ndr_pull_align(ndr, 4));
13295                 {
13296                         uint32_t _flags_save_string = ndr->flags;
13297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13298                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13299                         if (_ptr_file_name) {
13300                                 NDR_PULL_ALLOC(ndr, r->file_name);
13301                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13302                         } else {
13303                                 r->file_name = NULL;
13304                         }
13305                         ndr->flags = _flags_save_string;
13306                 }
13307                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13309         }
13310         if (ndr_flags & NDR_BUFFERS) {
13311                 {
13312                         uint32_t _flags_save_string = ndr->flags;
13313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13314                         if (r->file_name) {
13315                                 uint32_t _relative_save_offset;
13316                                 _relative_save_offset = ndr->offset;
13317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13318                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13319                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13322                                 ndr->offset = _relative_save_offset;
13323                         }
13324                         ndr->flags = _flags_save_string;
13325                 }
13326         }
13327         return NDR_ERR_SUCCESS;
13328 }
13329
13330 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13331 {
13332         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13333         ndr->depth++;
13334         ndr_print_ptr(ndr, "file_name", r->file_name);
13335         ndr->depth++;
13336         if (r->file_name) {
13337                 ndr_print_string(ndr, "file_name", r->file_name);
13338         }
13339         ndr->depth--;
13340         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13341         ndr_print_uint32(ndr, "file_version", r->file_version);
13342         ndr->depth--;
13343 }
13344
13345 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13346 {
13347         uint32_t cntr_file_info_1;
13348         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13349         ndr->depth++;
13350         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13351         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13352         ndr->depth++;
13353         if (r->driver_name) {
13354                 ndr_print_string(ndr, "driver_name", r->driver_name);
13355         }
13356         ndr->depth--;
13357         ndr_print_ptr(ndr, "architecture", r->architecture);
13358         ndr->depth++;
13359         if (r->architecture) {
13360                 ndr_print_string(ndr, "architecture", r->architecture);
13361         }
13362         ndr->depth--;
13363         ndr_print_ptr(ndr, "file_info", r->file_info);
13364         ndr->depth++;
13365         if (r->file_info) {
13366                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13367                 ndr->depth++;
13368                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13369                         char *idx_1=NULL;
13370                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13371                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13372                                 free(idx_1);
13373                         }
13374                 }
13375                 ndr->depth--;
13376         }
13377         ndr->depth--;
13378         ndr_print_uint32(ndr, "file_count", r->file_count);
13379         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13380         ndr->depth++;
13381         if (r->monitor_name) {
13382                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13383         }
13384         ndr->depth--;
13385         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13386         ndr->depth++;
13387         if (r->default_datatype) {
13388                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13389         }
13390         ndr->depth--;
13391         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13392         ndr->depth++;
13393         if (r->previous_names) {
13394                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13395         }
13396         ndr->depth--;
13397         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13398         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13399         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13400         ndr->depth++;
13401         if (r->manufacturer_name) {
13402                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13403         }
13404         ndr->depth--;
13405         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13406         ndr->depth++;
13407         if (r->manufacturer_url) {
13408                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13409         }
13410         ndr->depth--;
13411         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13412         ndr->depth++;
13413         if (r->hardware_id) {
13414                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13415         }
13416         ndr->depth--;
13417         ndr_print_ptr(ndr, "provider", r->provider);
13418         ndr->depth++;
13419         if (r->provider) {
13420                 ndr_print_string(ndr, "provider", r->provider);
13421         }
13422         ndr->depth--;
13423         ndr->depth--;
13424 }
13425
13426 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13427 {
13428         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13429 }
13430
13431 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13432 {
13433         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13434         if (ndr_flags & NDR_SCALARS) {
13435                 int level = ndr_push_get_switch_value(ndr, r);
13436                 switch (level) {
13437                         case 1: {
13438                                 NDR_CHECK(ndr_push_align(ndr, 4));
13439                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13440                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13441                         break; }
13442
13443                         case 2: {
13444                                 NDR_CHECK(ndr_push_align(ndr, 4));
13445                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13446                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13447                         break; }
13448
13449                         case 3: {
13450                                 NDR_CHECK(ndr_push_align(ndr, 4));
13451                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13452                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13453                         break; }
13454
13455                         case 4: {
13456                                 NDR_CHECK(ndr_push_align(ndr, 4));
13457                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13458                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13459                         break; }
13460
13461                         case 5: {
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_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13465                         break; }
13466
13467                         case 6: {
13468                                 NDR_CHECK(ndr_push_align(ndr, 8));
13469                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13471                         break; }
13472
13473                         case 8: {
13474                                 NDR_CHECK(ndr_push_align(ndr, 8));
13475                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13476                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13477                         break; }
13478
13479                         case 101: {
13480                                 NDR_CHECK(ndr_push_align(ndr, 8));
13481                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13482                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13483                         break; }
13484
13485                         default: {
13486                         break; }
13487
13488                 }
13489         }
13490         if (ndr_flags & NDR_BUFFERS) {
13491                 int level = ndr_push_get_switch_value(ndr, r);
13492                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13493                 switch (level) {
13494                         case 1:
13495                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13496                         break;
13497
13498                         case 2:
13499                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13500                         break;
13501
13502                         case 3:
13503                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13504                         break;
13505
13506                         case 4:
13507                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13508                         break;
13509
13510                         case 5:
13511                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13512                         break;
13513
13514                         case 6:
13515                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13516                         break;
13517
13518                         case 8:
13519                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13520                         break;
13521
13522                         case 101:
13523                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13524                         break;
13525
13526                         default:
13527                         break;
13528
13529                 }
13530         }
13531         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13532         return NDR_ERR_SUCCESS;
13533 }
13534
13535 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13536 {
13537         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13538         int level;
13539         level = ndr_pull_get_switch_value(ndr, r);
13540         if (ndr_flags & NDR_SCALARS) {
13541                 switch (level) {
13542                         case 1: {
13543                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13544                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13545                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13546                         break; }
13547
13548                         case 2: {
13549                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13550                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13551                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13552                         break; }
13553
13554                         case 3: {
13555                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13556                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13557                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13558                         break; }
13559
13560                         case 4: {
13561                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13562                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13563                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13564                         break; }
13565
13566                         case 5: {
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_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13570                         break; }
13571
13572                         case 6: {
13573                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13574                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13575                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13576                         break; }
13577
13578                         case 8: {
13579                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13580                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13581                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13582                         break; }
13583
13584                         case 101: {
13585                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13586                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13587                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13588                         break; }
13589
13590                         default: {
13591                         break; }
13592
13593                 }
13594         }
13595         if (ndr_flags & NDR_BUFFERS) {
13596                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13597                 switch (level) {
13598                         case 1:
13599                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13600                         break;
13601
13602                         case 2:
13603                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13604                         break;
13605
13606                         case 3:
13607                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13608                         break;
13609
13610                         case 4:
13611                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13612                         break;
13613
13614                         case 5:
13615                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13616                         break;
13617
13618                         case 6:
13619                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13620                         break;
13621
13622                         case 8:
13623                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13624                         break;
13625
13626                         case 101:
13627                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13628                         break;
13629
13630                         default:
13631                         break;
13632
13633                 }
13634         }
13635         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13636         return NDR_ERR_SUCCESS;
13637 }
13638
13639 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13640 {
13641         int level;
13642         level = ndr_print_get_switch_value(ndr, r);
13643         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13644         switch (level) {
13645                 case 1:
13646                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13647                 break;
13648
13649                 case 2:
13650                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13651                 break;
13652
13653                 case 3:
13654                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13655                 break;
13656
13657                 case 4:
13658                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13659                 break;
13660
13661                 case 5:
13662                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13663                 break;
13664
13665                 case 6:
13666                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13667                 break;
13668
13669                 case 8:
13670                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13671                 break;
13672
13673                 case 101:
13674                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13675                 break;
13676
13677                 default:
13678                 break;
13679
13680         }
13681 }
13682
13683 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13684 {
13685         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13686 }
13687
13688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13689 {
13690         if (ndr_flags & NDR_SCALARS) {
13691                 NDR_CHECK(ndr_push_align(ndr, 4));
13692                 {
13693                         uint32_t _flags_save_string = ndr->flags;
13694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13695                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13696                         ndr->flags = _flags_save_string;
13697                 }
13698         }
13699         if (ndr_flags & NDR_BUFFERS) {
13700         }
13701         return NDR_ERR_SUCCESS;
13702 }
13703
13704 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13705 {
13706         if (ndr_flags & NDR_SCALARS) {
13707                 NDR_CHECK(ndr_pull_align(ndr, 4));
13708                 {
13709                         uint32_t _flags_save_string = ndr->flags;
13710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13711                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13712                         ndr->flags = _flags_save_string;
13713                 }
13714         }
13715         if (ndr_flags & NDR_BUFFERS) {
13716         }
13717         return NDR_ERR_SUCCESS;
13718 }
13719
13720 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13721 {
13722         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13723         ndr->depth++;
13724         ndr_print_string(ndr, "directory_name", r->directory_name);
13725         ndr->depth--;
13726 }
13727
13728 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13729 {
13730         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13731 }
13732
13733 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13734 {
13735         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13736         if (ndr_flags & NDR_SCALARS) {
13737                 int level = ndr_push_get_switch_value(ndr, r);
13738                 switch (level) {
13739                         case 1: {
13740                                 NDR_CHECK(ndr_push_align(ndr, 4));
13741                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13742                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13743                         break; }
13744
13745                         default: {
13746                                 NDR_CHECK(ndr_push_align(ndr, 4));
13747                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13748                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13749                         break; }
13750
13751                 }
13752         }
13753         if (ndr_flags & NDR_BUFFERS) {
13754                 int level = ndr_push_get_switch_value(ndr, r);
13755                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13756                 switch (level) {
13757                         case 1:
13758                         break;
13759
13760                         default:
13761                         break;
13762
13763                 }
13764         }
13765         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13766         return NDR_ERR_SUCCESS;
13767 }
13768
13769 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13770 {
13771         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13772         int level;
13773         level = ndr_pull_get_switch_value(ndr, r);
13774         if (ndr_flags & NDR_SCALARS) {
13775                 switch (level) {
13776                         case 1: {
13777                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13778                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13779                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13780                         break; }
13781
13782                         default: {
13783                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13784                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13785                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13786                         break; }
13787
13788                 }
13789         }
13790         if (ndr_flags & NDR_BUFFERS) {
13791                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13792                 switch (level) {
13793                         case 1:
13794                         break;
13795
13796                         default:
13797                         break;
13798
13799                 }
13800         }
13801         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13802         return NDR_ERR_SUCCESS;
13803 }
13804
13805 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13806 {
13807         int level;
13808         level = ndr_print_get_switch_value(ndr, r);
13809         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13810         switch (level) {
13811                 case 1:
13812                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13813                 break;
13814
13815                 default:
13816                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13817                 break;
13818
13819         }
13820 }
13821
13822 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13823 {
13824         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13825 }
13826
13827 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13828 {
13829         if (ndr_flags & NDR_SCALARS) {
13830                 NDR_CHECK(ndr_push_align(ndr, 4));
13831                 {
13832                         uint32_t _flags_save_string = ndr->flags;
13833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13834                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13835                         ndr->flags = _flags_save_string;
13836                 }
13837         }
13838         if (ndr_flags & NDR_BUFFERS) {
13839                 {
13840                         uint32_t _flags_save_string = ndr->flags;
13841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13842                         if (r->print_processor_name) {
13843                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13844                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13845                         }
13846                         ndr->flags = _flags_save_string;
13847                 }
13848         }
13849         return NDR_ERR_SUCCESS;
13850 }
13851
13852 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13853 {
13854         uint32_t _ptr_print_processor_name;
13855         TALLOC_CTX *_mem_save_print_processor_name_0;
13856         if (ndr_flags & NDR_SCALARS) {
13857                 NDR_CHECK(ndr_pull_align(ndr, 4));
13858                 {
13859                         uint32_t _flags_save_string = ndr->flags;
13860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13861                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13862                         if (_ptr_print_processor_name) {
13863                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13864                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13865                         } else {
13866                                 r->print_processor_name = NULL;
13867                         }
13868                         ndr->flags = _flags_save_string;
13869                 }
13870         }
13871         if (ndr_flags & NDR_BUFFERS) {
13872                 {
13873                         uint32_t _flags_save_string = ndr->flags;
13874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13875                         if (r->print_processor_name) {
13876                                 uint32_t _relative_save_offset;
13877                                 _relative_save_offset = ndr->offset;
13878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13879                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13880                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13883                                 ndr->offset = _relative_save_offset;
13884                         }
13885                         ndr->flags = _flags_save_string;
13886                 }
13887         }
13888         return NDR_ERR_SUCCESS;
13889 }
13890
13891 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13892 {
13893         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13894         ndr->depth++;
13895         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13896         ndr->depth++;
13897         if (r->print_processor_name) {
13898                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13899         }
13900         ndr->depth--;
13901         ndr->depth--;
13902 }
13903
13904 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13905 {
13906         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13907 }
13908
13909 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13910 {
13911         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13912         if (ndr_flags & NDR_SCALARS) {
13913                 int level = ndr_push_get_switch_value(ndr, r);
13914                 switch (level) {
13915                         case 1: {
13916                                 NDR_CHECK(ndr_push_align(ndr, 4));
13917                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13918                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13919                         break; }
13920
13921                         default: {
13922                         break; }
13923
13924                 }
13925         }
13926         if (ndr_flags & NDR_BUFFERS) {
13927                 int level = ndr_push_get_switch_value(ndr, r);
13928                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13929                 switch (level) {
13930                         case 1:
13931                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13932                         break;
13933
13934                         default:
13935                         break;
13936
13937                 }
13938         }
13939         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13940         return NDR_ERR_SUCCESS;
13941 }
13942
13943 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13944 {
13945         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13946         int level;
13947         level = ndr_pull_get_switch_value(ndr, r);
13948         if (ndr_flags & NDR_SCALARS) {
13949                 switch (level) {
13950                         case 1: {
13951                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13952                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13953                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13954                         break; }
13955
13956                         default: {
13957                         break; }
13958
13959                 }
13960         }
13961         if (ndr_flags & NDR_BUFFERS) {
13962                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13963                 switch (level) {
13964                         case 1:
13965                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13966                         break;
13967
13968                         default:
13969                         break;
13970
13971                 }
13972         }
13973         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13974         return NDR_ERR_SUCCESS;
13975 }
13976
13977 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13978 {
13979         int level;
13980         level = ndr_print_get_switch_value(ndr, r);
13981         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13982         switch (level) {
13983                 case 1:
13984                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13985                 break;
13986
13987                 default:
13988                 break;
13989
13990         }
13991 }
13992
13993 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13994 {
13995         if (ndr_flags & NDR_SCALARS) {
13996                 NDR_CHECK(ndr_push_align(ndr, 4));
13997                 {
13998                         uint32_t _flags_save_string = ndr->flags;
13999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14000                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14001                         ndr->flags = _flags_save_string;
14002                 }
14003         }
14004         if (ndr_flags & NDR_BUFFERS) {
14005         }
14006         return NDR_ERR_SUCCESS;
14007 }
14008
14009 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14010 {
14011         if (ndr_flags & NDR_SCALARS) {
14012                 NDR_CHECK(ndr_pull_align(ndr, 4));
14013                 {
14014                         uint32_t _flags_save_string = ndr->flags;
14015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14016                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14017                         ndr->flags = _flags_save_string;
14018                 }
14019         }
14020         if (ndr_flags & NDR_BUFFERS) {
14021         }
14022         return NDR_ERR_SUCCESS;
14023 }
14024
14025 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14026 {
14027         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14028         ndr->depth++;
14029         ndr_print_string(ndr, "directory_name", r->directory_name);
14030         ndr->depth--;
14031 }
14032
14033 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14034 {
14035         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14036 }
14037
14038 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14039 {
14040         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14041         if (ndr_flags & NDR_SCALARS) {
14042                 int level = ndr_push_get_switch_value(ndr, r);
14043                 switch (level) {
14044                         case 1: {
14045                                 NDR_CHECK(ndr_push_align(ndr, 4));
14046                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14047                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14048                         break; }
14049
14050                         default: {
14051                                 NDR_CHECK(ndr_push_align(ndr, 4));
14052                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14053                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14054                         break; }
14055
14056                 }
14057         }
14058         if (ndr_flags & NDR_BUFFERS) {
14059                 int level = ndr_push_get_switch_value(ndr, r);
14060                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14061                 switch (level) {
14062                         case 1:
14063                         break;
14064
14065                         default:
14066                         break;
14067
14068                 }
14069         }
14070         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14071         return NDR_ERR_SUCCESS;
14072 }
14073
14074 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14075 {
14076         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14077         int level;
14078         level = ndr_pull_get_switch_value(ndr, r);
14079         if (ndr_flags & NDR_SCALARS) {
14080                 switch (level) {
14081                         case 1: {
14082                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14083                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14084                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14085                         break; }
14086
14087                         default: {
14088                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14089                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14090                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14091                         break; }
14092
14093                 }
14094         }
14095         if (ndr_flags & NDR_BUFFERS) {
14096                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14097                 switch (level) {
14098                         case 1:
14099                         break;
14100
14101                         default:
14102                         break;
14103
14104                 }
14105         }
14106         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14107         return NDR_ERR_SUCCESS;
14108 }
14109
14110 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14111 {
14112         int level;
14113         level = ndr_print_get_switch_value(ndr, r);
14114         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14115         switch (level) {
14116                 case 1:
14117                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14118                 break;
14119
14120                 default:
14121                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14122                 break;
14123
14124         }
14125 }
14126
14127 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14128 {
14129         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14130 }
14131
14132 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14133 {
14134         if (ndr_flags & NDR_SCALARS) {
14135                 NDR_CHECK(ndr_push_align(ndr, 4));
14136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14139         }
14140         if (ndr_flags & NDR_BUFFERS) {
14141                 if (r->document_name) {
14142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14145                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14146                 }
14147                 if (r->output_file) {
14148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14151                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14152                 }
14153                 if (r->datatype) {
14154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14158                 }
14159         }
14160         return NDR_ERR_SUCCESS;
14161 }
14162
14163 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14164 {
14165         uint32_t _ptr_document_name;
14166         TALLOC_CTX *_mem_save_document_name_0;
14167         uint32_t _ptr_output_file;
14168         TALLOC_CTX *_mem_save_output_file_0;
14169         uint32_t _ptr_datatype;
14170         TALLOC_CTX *_mem_save_datatype_0;
14171         if (ndr_flags & NDR_SCALARS) {
14172                 NDR_CHECK(ndr_pull_align(ndr, 4));
14173                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14174                 if (_ptr_document_name) {
14175                         NDR_PULL_ALLOC(ndr, r->document_name);
14176                 } else {
14177                         r->document_name = NULL;
14178                 }
14179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14180                 if (_ptr_output_file) {
14181                         NDR_PULL_ALLOC(ndr, r->output_file);
14182                 } else {
14183                         r->output_file = NULL;
14184                 }
14185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14186                 if (_ptr_datatype) {
14187                         NDR_PULL_ALLOC(ndr, r->datatype);
14188                 } else {
14189                         r->datatype = NULL;
14190                 }
14191         }
14192         if (ndr_flags & NDR_BUFFERS) {
14193                 if (r->document_name) {
14194                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14195                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14198                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14199                                 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));
14200                         }
14201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14204                 }
14205                 if (r->output_file) {
14206                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14207                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14210                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14211                                 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));
14212                         }
14213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14216                 }
14217                 if (r->datatype) {
14218                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14219                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14222                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
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->datatype), ndr_get_array_length(ndr, &r->datatype));
14224                         }
14225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14228                 }
14229         }
14230         return NDR_ERR_SUCCESS;
14231 }
14232
14233 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14234 {
14235         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14236         ndr->depth++;
14237         ndr_print_ptr(ndr, "document_name", r->document_name);
14238         ndr->depth++;
14239         if (r->document_name) {
14240                 ndr_print_string(ndr, "document_name", r->document_name);
14241         }
14242         ndr->depth--;
14243         ndr_print_ptr(ndr, "output_file", r->output_file);
14244         ndr->depth++;
14245         if (r->output_file) {
14246                 ndr_print_string(ndr, "output_file", r->output_file);
14247         }
14248         ndr->depth--;
14249         ndr_print_ptr(ndr, "datatype", r->datatype);
14250         ndr->depth++;
14251         if (r->datatype) {
14252                 ndr_print_string(ndr, "datatype", r->datatype);
14253         }
14254         ndr->depth--;
14255         ndr->depth--;
14256 }
14257
14258 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14259 {
14260         if (ndr_flags & NDR_SCALARS) {
14261                 int level = ndr_push_get_switch_value(ndr, r);
14262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14263                 switch (level) {
14264                         case 1: {
14265                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14266                         break; }
14267
14268                         case 2: {
14269                         break; }
14270
14271                         case 3: {
14272                         break; }
14273
14274                         default: {
14275                         break; }
14276
14277                 }
14278         }
14279         if (ndr_flags & NDR_BUFFERS) {
14280                 int level = ndr_push_get_switch_value(ndr, r);
14281                 switch (level) {
14282                         case 1:
14283                                 if (r->info1) {
14284                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14285                                 }
14286                         break;
14287
14288                         case 2:
14289                         break;
14290
14291                         case 3:
14292                         break;
14293
14294                         default:
14295                         break;
14296
14297                 }
14298         }
14299         return NDR_ERR_SUCCESS;
14300 }
14301
14302 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14303 {
14304         int level;
14305         uint32_t _level;
14306         TALLOC_CTX *_mem_save_info1_0;
14307         level = ndr_pull_get_switch_value(ndr, r);
14308         if (ndr_flags & NDR_SCALARS) {
14309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14310                 if (_level != level) {
14311                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14312                 }
14313                 switch (level) {
14314                         case 1: {
14315                                 uint32_t _ptr_info1;
14316                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14317                                 if (_ptr_info1) {
14318                                         NDR_PULL_ALLOC(ndr, r->info1);
14319                                 } else {
14320                                         r->info1 = NULL;
14321                                 }
14322                         break; }
14323
14324                         case 2: {
14325                         break; }
14326
14327                         case 3: {
14328                         break; }
14329
14330                         default: {
14331                         break; }
14332
14333                 }
14334         }
14335         if (ndr_flags & NDR_BUFFERS) {
14336                 switch (level) {
14337                         case 1:
14338                                 if (r->info1) {
14339                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14340                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14341                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14342                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14343                                 }
14344                         break;
14345
14346                         case 2:
14347                         break;
14348
14349                         case 3:
14350                         break;
14351
14352                         default:
14353                         break;
14354
14355                 }
14356         }
14357         return NDR_ERR_SUCCESS;
14358 }
14359
14360 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14361 {
14362         int level;
14363         level = ndr_print_get_switch_value(ndr, r);
14364         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14365         switch (level) {
14366                 case 1:
14367                         ndr_print_ptr(ndr, "info1", r->info1);
14368                         ndr->depth++;
14369                         if (r->info1) {
14370                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14371                         }
14372                         ndr->depth--;
14373                 break;
14374
14375                 case 2:
14376                 break;
14377
14378                 case 3:
14379                 break;
14380
14381                 default:
14382                 break;
14383
14384         }
14385 }
14386
14387 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14388 {
14389         if (ndr_flags & NDR_SCALARS) {
14390                 NDR_CHECK(ndr_push_align(ndr, 4));
14391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14396                 {
14397                         uint32_t _flags_save_string = ndr->flags;
14398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14399                         {
14400                                 struct ndr_push *_ndr_extra_string;
14401                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14402                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14403                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14404                         }
14405                         ndr->flags = _flags_save_string;
14406                 }
14407         }
14408         if (ndr_flags & NDR_BUFFERS) {
14409         }
14410         return NDR_ERR_SUCCESS;
14411 }
14412
14413 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14414 {
14415         if (ndr_flags & NDR_SCALARS) {
14416                 NDR_CHECK(ndr_pull_align(ndr, 4));
14417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14422                 {
14423                         uint32_t _flags_save_string = ndr->flags;
14424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14425                         {
14426                                 struct ndr_pull *_ndr_extra_string;
14427                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14428                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14429                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14430                         }
14431                         ndr->flags = _flags_save_string;
14432                 }
14433         }
14434         if (ndr_flags & NDR_BUFFERS) {
14435         }
14436         return NDR_ERR_SUCCESS;
14437 }
14438
14439 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14440 {
14441         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14442         ndr->depth++;
14443         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);
14444         ndr_print_uint32(ndr, "major", r->major);
14445         ndr_print_uint32(ndr, "minor", r->minor);
14446         ndr_print_uint32(ndr, "build", r->build);
14447         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14448         ndr_print_string(ndr, "extra_string", r->extra_string);
14449         ndr->depth--;
14450 }
14451
14452 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14453 {
14454         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14455 }
14456
14457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14458 {
14459         if (ndr_flags & NDR_SCALARS) {
14460                 NDR_CHECK(ndr_push_align(ndr, 4));
14461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14466                 {
14467                         uint32_t _flags_save_string = ndr->flags;
14468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14469                         {
14470                                 struct ndr_push *_ndr_extra_string;
14471                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14472                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14473                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14474                         }
14475                         ndr->flags = _flags_save_string;
14476                 }
14477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14479         }
14480         if (ndr_flags & NDR_BUFFERS) {
14481         }
14482         return NDR_ERR_SUCCESS;
14483 }
14484
14485 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14486 {
14487         if (ndr_flags & NDR_SCALARS) {
14488                 NDR_CHECK(ndr_pull_align(ndr, 4));
14489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14494                 {
14495                         uint32_t _flags_save_string = ndr->flags;
14496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14497                         {
14498                                 struct ndr_pull *_ndr_extra_string;
14499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14500                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14502                         }
14503                         ndr->flags = _flags_save_string;
14504                 }
14505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14507         }
14508         if (ndr_flags & NDR_BUFFERS) {
14509         }
14510         return NDR_ERR_SUCCESS;
14511 }
14512
14513 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14514 {
14515         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14516         ndr->depth++;
14517         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);
14518         ndr_print_uint32(ndr, "major", r->major);
14519         ndr_print_uint32(ndr, "minor", r->minor);
14520         ndr_print_uint32(ndr, "build", r->build);
14521         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14522         ndr_print_string(ndr, "extra_string", r->extra_string);
14523         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14524         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14525         ndr->depth--;
14526 }
14527
14528 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14529 {
14530         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14531 }
14532
14533 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14534 {
14535         if (ndr_flags & NDR_SCALARS) {
14536                 int level = ndr_push_get_switch_value(ndr, r);
14537                 switch (level) {
14538                         case REG_NONE: {
14539                         break; }
14540
14541                         case REG_SZ: {
14542                                 {
14543                                         uint32_t _flags_save_string = ndr->flags;
14544                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14545                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14546                                         ndr->flags = _flags_save_string;
14547                                 }
14548                         break; }
14549
14550                         case REG_BINARY: {
14551                                 {
14552                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14553                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14554                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14555                                         ndr->flags = _flags_save_DATA_BLOB;
14556                                 }
14557                         break; }
14558
14559                         case REG_DWORD: {
14560                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14561                         break; }
14562
14563                         case REG_MULTI_SZ: {
14564                                 {
14565                                         uint32_t _flags_save_string_array = ndr->flags;
14566                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14567                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14568                                         ndr->flags = _flags_save_string_array;
14569                                 }
14570                         break; }
14571
14572                         default: {
14573                                 {
14574                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14575                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14576                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14577                                         ndr->flags = _flags_save_DATA_BLOB;
14578                                 }
14579                         break; }
14580
14581                 }
14582         }
14583         if (ndr_flags & NDR_BUFFERS) {
14584                 int level = ndr_push_get_switch_value(ndr, r);
14585                 switch (level) {
14586                         case REG_NONE:
14587                         break;
14588
14589                         case REG_SZ:
14590                         break;
14591
14592                         case REG_BINARY:
14593                         break;
14594
14595                         case REG_DWORD:
14596                         break;
14597
14598                         case REG_MULTI_SZ:
14599                         break;
14600
14601                         default:
14602                         break;
14603
14604                 }
14605         }
14606         return NDR_ERR_SUCCESS;
14607 }
14608
14609 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14610 {
14611         int level;
14612         level = ndr_pull_get_switch_value(ndr, r);
14613         if (ndr_flags & NDR_SCALARS) {
14614                 switch (level) {
14615                         case REG_NONE: {
14616                         break; }
14617
14618                         case REG_SZ: {
14619                                 {
14620                                         uint32_t _flags_save_string = ndr->flags;
14621                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14622                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14623                                         ndr->flags = _flags_save_string;
14624                                 }
14625                         break; }
14626
14627                         case REG_BINARY: {
14628                                 {
14629                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14630                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14631                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14632                                         ndr->flags = _flags_save_DATA_BLOB;
14633                                 }
14634                         break; }
14635
14636                         case REG_DWORD: {
14637                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14638                         break; }
14639
14640                         case REG_MULTI_SZ: {
14641                                 {
14642                                         uint32_t _flags_save_string_array = ndr->flags;
14643                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14644                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14645                                         ndr->flags = _flags_save_string_array;
14646                                 }
14647                         break; }
14648
14649                         default: {
14650                                 {
14651                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14652                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14653                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14654                                         ndr->flags = _flags_save_DATA_BLOB;
14655                                 }
14656                         break; }
14657
14658                 }
14659         }
14660         if (ndr_flags & NDR_BUFFERS) {
14661                 switch (level) {
14662                         case REG_NONE:
14663                         break;
14664
14665                         case REG_SZ:
14666                         break;
14667
14668                         case REG_BINARY:
14669                         break;
14670
14671                         case REG_DWORD:
14672                         break;
14673
14674                         case REG_MULTI_SZ:
14675                         break;
14676
14677                         default:
14678                         break;
14679
14680                 }
14681         }
14682         return NDR_ERR_SUCCESS;
14683 }
14684
14685 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14686 {
14687         int level;
14688         level = ndr_print_get_switch_value(ndr, r);
14689         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14690         switch (level) {
14691                 case REG_NONE:
14692                 break;
14693
14694                 case REG_SZ:
14695                         ndr_print_string(ndr, "string", r->string);
14696                 break;
14697
14698                 case REG_BINARY:
14699                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14700                 break;
14701
14702                 case REG_DWORD:
14703                         ndr_print_uint32(ndr, "value", r->value);
14704                 break;
14705
14706                 case REG_MULTI_SZ:
14707                         ndr_print_string_array(ndr, "string_array", r->string_array);
14708                 break;
14709
14710                 default:
14711                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14712                 break;
14713
14714         }
14715 }
14716
14717 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14718 {
14719         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14720 }
14721
14722 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14723 {
14724         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14725         return NDR_ERR_SUCCESS;
14726 }
14727
14728 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14729 {
14730         uint32_t v;
14731         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14732         *r = v;
14733         return NDR_ERR_SUCCESS;
14734 }
14735
14736 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14737 {
14738         const char *val = NULL;
14739
14740         switch (r) {
14741                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14742                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14743                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14744         }
14745         ndr_print_enum(ndr, name, "ENUM", val, r);
14746 }
14747
14748 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14749 {
14750         if (ndr_flags & NDR_SCALARS) {
14751                 NDR_CHECK(ndr_push_align(ndr, 4));
14752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14754         }
14755         if (ndr_flags & NDR_BUFFERS) {
14756         }
14757         return NDR_ERR_SUCCESS;
14758 }
14759
14760 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14761 {
14762         if (ndr_flags & NDR_SCALARS) {
14763                 NDR_CHECK(ndr_pull_align(ndr, 4));
14764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14766         }
14767         if (ndr_flags & NDR_BUFFERS) {
14768         }
14769         return NDR_ERR_SUCCESS;
14770 }
14771
14772 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14773 {
14774         ndr_print_struct(ndr, name, "spoolss_FormSize");
14775         ndr->depth++;
14776         ndr_print_uint32(ndr, "width", r->width);
14777         ndr_print_uint32(ndr, "height", r->height);
14778         ndr->depth--;
14779 }
14780
14781 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14782 {
14783         if (ndr_flags & NDR_SCALARS) {
14784                 NDR_CHECK(ndr_push_align(ndr, 4));
14785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14789         }
14790         if (ndr_flags & NDR_BUFFERS) {
14791         }
14792         return NDR_ERR_SUCCESS;
14793 }
14794
14795 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14796 {
14797         if (ndr_flags & NDR_SCALARS) {
14798                 NDR_CHECK(ndr_pull_align(ndr, 4));
14799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14803         }
14804         if (ndr_flags & NDR_BUFFERS) {
14805         }
14806         return NDR_ERR_SUCCESS;
14807 }
14808
14809 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14810 {
14811         ndr_print_struct(ndr, name, "spoolss_FormArea");
14812         ndr->depth++;
14813         ndr_print_uint32(ndr, "left", r->left);
14814         ndr_print_uint32(ndr, "top", r->top);
14815         ndr_print_uint32(ndr, "right", r->right);
14816         ndr_print_uint32(ndr, "bottom", r->bottom);
14817         ndr->depth--;
14818 }
14819
14820 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14821 {
14822         if (ndr_flags & NDR_SCALARS) {
14823                 NDR_CHECK(ndr_push_align(ndr, 4));
14824                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14825                 {
14826                         uint32_t _flags_save_string = ndr->flags;
14827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14828                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14829                         ndr->flags = _flags_save_string;
14830                 }
14831                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14832                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14833         }
14834         if (ndr_flags & NDR_BUFFERS) {
14835                 {
14836                         uint32_t _flags_save_string = ndr->flags;
14837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14838                         if (r->form_name) {
14839                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14840                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14841                         }
14842                         ndr->flags = _flags_save_string;
14843                 }
14844         }
14845         return NDR_ERR_SUCCESS;
14846 }
14847
14848 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14849 {
14850         uint32_t _ptr_form_name;
14851         TALLOC_CTX *_mem_save_form_name_0;
14852         if (ndr_flags & NDR_SCALARS) {
14853                 NDR_CHECK(ndr_pull_align(ndr, 4));
14854                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14855                 {
14856                         uint32_t _flags_save_string = ndr->flags;
14857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14858                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14859                         if (_ptr_form_name) {
14860                                 NDR_PULL_ALLOC(ndr, r->form_name);
14861                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14862                         } else {
14863                                 r->form_name = NULL;
14864                         }
14865                         ndr->flags = _flags_save_string;
14866                 }
14867                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14868                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14869         }
14870         if (ndr_flags & NDR_BUFFERS) {
14871                 {
14872                         uint32_t _flags_save_string = ndr->flags;
14873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14874                         if (r->form_name) {
14875                                 uint32_t _relative_save_offset;
14876                                 _relative_save_offset = ndr->offset;
14877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14878                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14879                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14880                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14881                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14882                                 ndr->offset = _relative_save_offset;
14883                         }
14884                         ndr->flags = _flags_save_string;
14885                 }
14886         }
14887         return NDR_ERR_SUCCESS;
14888 }
14889
14890 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14891 {
14892         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14893         ndr->depth++;
14894         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14895         ndr_print_ptr(ndr, "form_name", r->form_name);
14896         ndr->depth++;
14897         if (r->form_name) {
14898                 ndr_print_string(ndr, "form_name", r->form_name);
14899         }
14900         ndr->depth--;
14901         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14902         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14903         ndr->depth--;
14904 }
14905
14906 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14907 {
14908         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14909 }
14910
14911 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14912 {
14913         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14914         return NDR_ERR_SUCCESS;
14915 }
14916
14917 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14918 {
14919         uint32_t v;
14920         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14921         *r = v;
14922         return NDR_ERR_SUCCESS;
14923 }
14924
14925 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14926 {
14927         ndr_print_uint32(ndr, name, r);
14928         ndr->depth++;
14929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14932         ndr->depth--;
14933 }
14934
14935 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14936 {
14937         if (ndr_flags & NDR_SCALARS) {
14938                 NDR_CHECK(ndr_push_align(ndr, 4));
14939                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14940                 {
14941                         uint32_t _flags_save_string = ndr->flags;
14942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14944                         ndr->flags = _flags_save_string;
14945                 }
14946                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14947                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14948                 {
14949                         uint32_t _flags_save_string = ndr->flags;
14950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14952                         ndr->flags = _flags_save_string;
14953                 }
14954                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14955                 {
14956                         uint32_t _flags_save_string = ndr->flags;
14957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14958                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14959                         ndr->flags = _flags_save_string;
14960                 }
14961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14962                 {
14963                         uint32_t _flags_save_string = ndr->flags;
14964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14965                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14966                         ndr->flags = _flags_save_string;
14967                 }
14968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14969         }
14970         if (ndr_flags & NDR_BUFFERS) {
14971                 {
14972                         uint32_t _flags_save_string = ndr->flags;
14973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14974                         if (r->form_name) {
14975                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14976                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14977                         }
14978                         ndr->flags = _flags_save_string;
14979                 }
14980                 {
14981                         uint32_t _flags_save_string = ndr->flags;
14982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14983                         if (r->keyword) {
14984                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
14985                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
14986                         }
14987                         ndr->flags = _flags_save_string;
14988                 }
14989                 {
14990                         uint32_t _flags_save_string = ndr->flags;
14991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14992                         if (r->mui_dll) {
14993                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
14994                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
14995                         }
14996                         ndr->flags = _flags_save_string;
14997                 }
14998                 {
14999                         uint32_t _flags_save_string = ndr->flags;
15000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15001                         if (r->display_name) {
15002                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15003                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15004                         }
15005                         ndr->flags = _flags_save_string;
15006                 }
15007         }
15008         return NDR_ERR_SUCCESS;
15009 }
15010
15011 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15012 {
15013         uint32_t _ptr_form_name;
15014         TALLOC_CTX *_mem_save_form_name_0;
15015         uint32_t _ptr_keyword;
15016         TALLOC_CTX *_mem_save_keyword_0;
15017         uint32_t _ptr_mui_dll;
15018         TALLOC_CTX *_mem_save_mui_dll_0;
15019         uint32_t _ptr_display_name;
15020         TALLOC_CTX *_mem_save_display_name_0;
15021         if (ndr_flags & NDR_SCALARS) {
15022                 NDR_CHECK(ndr_pull_align(ndr, 4));
15023                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15024                 {
15025                         uint32_t _flags_save_string = ndr->flags;
15026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15027                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15028                         if (_ptr_form_name) {
15029                                 NDR_PULL_ALLOC(ndr, r->form_name);
15030                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15031                         } else {
15032                                 r->form_name = NULL;
15033                         }
15034                         ndr->flags = _flags_save_string;
15035                 }
15036                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15037                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15038                 {
15039                         uint32_t _flags_save_string = ndr->flags;
15040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15041                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15042                         if (_ptr_keyword) {
15043                                 NDR_PULL_ALLOC(ndr, r->keyword);
15044                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15045                         } else {
15046                                 r->keyword = NULL;
15047                         }
15048                         ndr->flags = _flags_save_string;
15049                 }
15050                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15051                 {
15052                         uint32_t _flags_save_string = ndr->flags;
15053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15054                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15055                         if (_ptr_mui_dll) {
15056                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15057                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15058                         } else {
15059                                 r->mui_dll = NULL;
15060                         }
15061                         ndr->flags = _flags_save_string;
15062                 }
15063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15064                 {
15065                         uint32_t _flags_save_string = ndr->flags;
15066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15067                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15068                         if (_ptr_display_name) {
15069                                 NDR_PULL_ALLOC(ndr, r->display_name);
15070                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15071                         } else {
15072                                 r->display_name = NULL;
15073                         }
15074                         ndr->flags = _flags_save_string;
15075                 }
15076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15077         }
15078         if (ndr_flags & NDR_BUFFERS) {
15079                 {
15080                         uint32_t _flags_save_string = ndr->flags;
15081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15082                         if (r->form_name) {
15083                                 uint32_t _relative_save_offset;
15084                                 _relative_save_offset = ndr->offset;
15085                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15086                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15087                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15088                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15089                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15090                                 ndr->offset = _relative_save_offset;
15091                         }
15092                         ndr->flags = _flags_save_string;
15093                 }
15094                 {
15095                         uint32_t _flags_save_string = ndr->flags;
15096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15097                         if (r->keyword) {
15098                                 uint32_t _relative_save_offset;
15099                                 _relative_save_offset = ndr->offset;
15100                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15101                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15102                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15103                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15104                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15105                                 ndr->offset = _relative_save_offset;
15106                         }
15107                         ndr->flags = _flags_save_string;
15108                 }
15109                 {
15110                         uint32_t _flags_save_string = ndr->flags;
15111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15112                         if (r->mui_dll) {
15113                                 uint32_t _relative_save_offset;
15114                                 _relative_save_offset = ndr->offset;
15115                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15116                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15117                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15118                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15119                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15120                                 ndr->offset = _relative_save_offset;
15121                         }
15122                         ndr->flags = _flags_save_string;
15123                 }
15124                 {
15125                         uint32_t _flags_save_string = ndr->flags;
15126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15127                         if (r->display_name) {
15128                                 uint32_t _relative_save_offset;
15129                                 _relative_save_offset = ndr->offset;
15130                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15131                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15132                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15133                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15134                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15135                                 ndr->offset = _relative_save_offset;
15136                         }
15137                         ndr->flags = _flags_save_string;
15138                 }
15139         }
15140         return NDR_ERR_SUCCESS;
15141 }
15142
15143 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15144 {
15145         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15146         ndr->depth++;
15147         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15148         ndr_print_ptr(ndr, "form_name", r->form_name);
15149         ndr->depth++;
15150         if (r->form_name) {
15151                 ndr_print_string(ndr, "form_name", r->form_name);
15152         }
15153         ndr->depth--;
15154         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15155         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15156         ndr_print_ptr(ndr, "keyword", r->keyword);
15157         ndr->depth++;
15158         if (r->keyword) {
15159                 ndr_print_string(ndr, "keyword", r->keyword);
15160         }
15161         ndr->depth--;
15162         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15163         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15164         ndr->depth++;
15165         if (r->mui_dll) {
15166                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15167         }
15168         ndr->depth--;
15169         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15170         ndr_print_ptr(ndr, "display_name", r->display_name);
15171         ndr->depth++;
15172         if (r->display_name) {
15173                 ndr_print_string(ndr, "display_name", r->display_name);
15174         }
15175         ndr->depth--;
15176         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15177         ndr->depth--;
15178 }
15179
15180 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15181 {
15182         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15183 }
15184
15185 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15186 {
15187         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15188         if (ndr_flags & NDR_SCALARS) {
15189                 int level = ndr_push_get_switch_value(ndr, r);
15190                 switch (level) {
15191                         case 1: {
15192                                 NDR_CHECK(ndr_push_align(ndr, 4));
15193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15194                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15195                         break; }
15196
15197                         case 2: {
15198                                 NDR_CHECK(ndr_push_align(ndr, 4));
15199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15200                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15201                         break; }
15202
15203                         default: {
15204                         break; }
15205
15206                 }
15207         }
15208         if (ndr_flags & NDR_BUFFERS) {
15209                 int level = ndr_push_get_switch_value(ndr, r);
15210                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15211                 switch (level) {
15212                         case 1:
15213                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15214                         break;
15215
15216                         case 2:
15217                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15218                         break;
15219
15220                         default:
15221                         break;
15222
15223                 }
15224         }
15225         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15226         return NDR_ERR_SUCCESS;
15227 }
15228
15229 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15230 {
15231         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15232         int level;
15233         level = ndr_pull_get_switch_value(ndr, r);
15234         if (ndr_flags & NDR_SCALARS) {
15235                 switch (level) {
15236                         case 1: {
15237                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15238                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15239                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15240                         break; }
15241
15242                         case 2: {
15243                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15244                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15245                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15246                         break; }
15247
15248                         default: {
15249                         break; }
15250
15251                 }
15252         }
15253         if (ndr_flags & NDR_BUFFERS) {
15254                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15255                 switch (level) {
15256                         case 1:
15257                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15258                         break;
15259
15260                         case 2:
15261                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15262                         break;
15263
15264                         default:
15265                         break;
15266
15267                 }
15268         }
15269         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15270         return NDR_ERR_SUCCESS;
15271 }
15272
15273 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15274 {
15275         int level;
15276         level = ndr_print_get_switch_value(ndr, r);
15277         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15278         switch (level) {
15279                 case 1:
15280                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15281                 break;
15282
15283                 case 2:
15284                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15285                 break;
15286
15287                 default:
15288                 break;
15289
15290         }
15291 }
15292
15293 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15294 {
15295         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15296 }
15297
15298 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15299 {
15300         if (ndr_flags & NDR_SCALARS) {
15301                 NDR_CHECK(ndr_push_align(ndr, 4));
15302                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15303                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15304                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15305                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15306         }
15307         if (ndr_flags & NDR_BUFFERS) {
15308                 if (r->form_name) {
15309                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15310                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15313                 }
15314         }
15315         return NDR_ERR_SUCCESS;
15316 }
15317
15318 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15319 {
15320         uint32_t _ptr_form_name;
15321         TALLOC_CTX *_mem_save_form_name_0;
15322         if (ndr_flags & NDR_SCALARS) {
15323                 NDR_CHECK(ndr_pull_align(ndr, 4));
15324                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15326                 if (_ptr_form_name) {
15327                         NDR_PULL_ALLOC(ndr, r->form_name);
15328                 } else {
15329                         r->form_name = NULL;
15330                 }
15331                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15332                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15333         }
15334         if (ndr_flags & NDR_BUFFERS) {
15335                 if (r->form_name) {
15336                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15337                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15338                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15339                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15340                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15341                                 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));
15342                         }
15343                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15344                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15346                 }
15347         }
15348         return NDR_ERR_SUCCESS;
15349 }
15350
15351 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15352 {
15353         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15354         ndr->depth++;
15355         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15356         ndr_print_ptr(ndr, "form_name", r->form_name);
15357         ndr->depth++;
15358         if (r->form_name) {
15359                 ndr_print_string(ndr, "form_name", r->form_name);
15360         }
15361         ndr->depth--;
15362         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15363         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15364         ndr->depth--;
15365 }
15366
15367 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15368 {
15369         if (ndr_flags & NDR_SCALARS) {
15370                 NDR_CHECK(ndr_push_align(ndr, 4));
15371                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15373                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15374                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15376                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15377                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15381         }
15382         if (ndr_flags & NDR_BUFFERS) {
15383                 if (r->form_name) {
15384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15387                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15388                 }
15389                 if (r->keyword) {
15390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15393                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15394                 }
15395                 if (r->mui_dll) {
15396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15399                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15400                 }
15401                 if (r->display_name) {
15402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15405                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15406                 }
15407         }
15408         return NDR_ERR_SUCCESS;
15409 }
15410
15411 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15412 {
15413         uint32_t _ptr_form_name;
15414         TALLOC_CTX *_mem_save_form_name_0;
15415         uint32_t _ptr_keyword;
15416         TALLOC_CTX *_mem_save_keyword_0;
15417         uint32_t _ptr_mui_dll;
15418         TALLOC_CTX *_mem_save_mui_dll_0;
15419         uint32_t _ptr_display_name;
15420         TALLOC_CTX *_mem_save_display_name_0;
15421         if (ndr_flags & NDR_SCALARS) {
15422                 NDR_CHECK(ndr_pull_align(ndr, 4));
15423                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15425                 if (_ptr_form_name) {
15426                         NDR_PULL_ALLOC(ndr, r->form_name);
15427                 } else {
15428                         r->form_name = NULL;
15429                 }
15430                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15431                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15433                 if (_ptr_keyword) {
15434                         NDR_PULL_ALLOC(ndr, r->keyword);
15435                 } else {
15436                         r->keyword = NULL;
15437                 }
15438                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15440                 if (_ptr_mui_dll) {
15441                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15442                 } else {
15443                         r->mui_dll = NULL;
15444                 }
15445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15447                 if (_ptr_display_name) {
15448                         NDR_PULL_ALLOC(ndr, r->display_name);
15449                 } else {
15450                         r->display_name = NULL;
15451                 }
15452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15453         }
15454         if (ndr_flags & NDR_BUFFERS) {
15455                 if (r->form_name) {
15456                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15457                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15458                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15459                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15460                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15461                                 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));
15462                         }
15463                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15464                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15466                 }
15467                 if (r->keyword) {
15468                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15469                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15470                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15471                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15472                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15473                                 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));
15474                         }
15475                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15476                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15477                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15478                 }
15479                 if (r->mui_dll) {
15480                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15481                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15482                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15483                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15484                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
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->mui_dll), ndr_get_array_length(ndr, &r->mui_dll));
15486                         }
15487                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15488                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15490                 }
15491                 if (r->display_name) {
15492                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15493                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15494                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15495                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15496                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
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->display_name), ndr_get_array_length(ndr, &r->display_name));
15498                         }
15499                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15500                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15502                 }
15503         }
15504         return NDR_ERR_SUCCESS;
15505 }
15506
15507 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15508 {
15509         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15510         ndr->depth++;
15511         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15512         ndr_print_ptr(ndr, "form_name", r->form_name);
15513         ndr->depth++;
15514         if (r->form_name) {
15515                 ndr_print_string(ndr, "form_name", r->form_name);
15516         }
15517         ndr->depth--;
15518         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15519         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15520         ndr_print_ptr(ndr, "keyword", r->keyword);
15521         ndr->depth++;
15522         if (r->keyword) {
15523                 ndr_print_string(ndr, "keyword", r->keyword);
15524         }
15525         ndr->depth--;
15526         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15527         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15528         ndr->depth++;
15529         if (r->mui_dll) {
15530                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15531         }
15532         ndr->depth--;
15533         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15534         ndr_print_ptr(ndr, "display_name", r->display_name);
15535         ndr->depth++;
15536         if (r->display_name) {
15537                 ndr_print_string(ndr, "display_name", r->display_name);
15538         }
15539         ndr->depth--;
15540         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15541         ndr->depth--;
15542 }
15543
15544 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15545 {
15546         if (ndr_flags & NDR_SCALARS) {
15547                 int level = ndr_push_get_switch_value(ndr, r);
15548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15549                 switch (level) {
15550                         case 1: {
15551                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15552                         break; }
15553
15554                         case 2: {
15555                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15556                         break; }
15557
15558                         default:
15559                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15560                 }
15561         }
15562         if (ndr_flags & NDR_BUFFERS) {
15563                 int level = ndr_push_get_switch_value(ndr, r);
15564                 switch (level) {
15565                         case 1:
15566                                 if (r->info1) {
15567                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15568                                 }
15569                         break;
15570
15571                         case 2:
15572                                 if (r->info2) {
15573                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15574                                 }
15575                         break;
15576
15577                         default:
15578                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15579                 }
15580         }
15581         return NDR_ERR_SUCCESS;
15582 }
15583
15584 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15585 {
15586         int level;
15587         uint32_t _level;
15588         TALLOC_CTX *_mem_save_info1_0;
15589         TALLOC_CTX *_mem_save_info2_0;
15590         level = ndr_pull_get_switch_value(ndr, r);
15591         if (ndr_flags & NDR_SCALARS) {
15592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15593                 if (_level != level) {
15594                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15595                 }
15596                 switch (level) {
15597                         case 1: {
15598                                 uint32_t _ptr_info1;
15599                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15600                                 if (_ptr_info1) {
15601                                         NDR_PULL_ALLOC(ndr, r->info1);
15602                                 } else {
15603                                         r->info1 = NULL;
15604                                 }
15605                         break; }
15606
15607                         case 2: {
15608                                 uint32_t _ptr_info2;
15609                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15610                                 if (_ptr_info2) {
15611                                         NDR_PULL_ALLOC(ndr, r->info2);
15612                                 } else {
15613                                         r->info2 = NULL;
15614                                 }
15615                         break; }
15616
15617                         default:
15618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15619                 }
15620         }
15621         if (ndr_flags & NDR_BUFFERS) {
15622                 switch (level) {
15623                         case 1:
15624                                 if (r->info1) {
15625                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15626                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15627                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15628                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15629                                 }
15630                         break;
15631
15632                         case 2:
15633                                 if (r->info2) {
15634                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15635                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15636                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15637                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15638                                 }
15639                         break;
15640
15641                         default:
15642                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15643                 }
15644         }
15645         return NDR_ERR_SUCCESS;
15646 }
15647
15648 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15649 {
15650         int level;
15651         level = ndr_print_get_switch_value(ndr, r);
15652         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15653         switch (level) {
15654                 case 1:
15655                         ndr_print_ptr(ndr, "info1", r->info1);
15656                         ndr->depth++;
15657                         if (r->info1) {
15658                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15659                         }
15660                         ndr->depth--;
15661                 break;
15662
15663                 case 2:
15664                         ndr_print_ptr(ndr, "info2", r->info2);
15665                         ndr->depth++;
15666                         if (r->info2) {
15667                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15668                         }
15669                         ndr->depth--;
15670                 break;
15671
15672                 default:
15673                         ndr_print_bad_level(ndr, name, level);
15674         }
15675 }
15676
15677 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15678 {
15679         if (ndr_flags & NDR_SCALARS) {
15680                 NDR_CHECK(ndr_push_align(ndr, 4));
15681                 {
15682                         uint32_t _flags_save_string = ndr->flags;
15683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15684                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15685                         ndr->flags = _flags_save_string;
15686                 }
15687         }
15688         if (ndr_flags & NDR_BUFFERS) {
15689                 {
15690                         uint32_t _flags_save_string = ndr->flags;
15691                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15692                         if (r->port_name) {
15693                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15694                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15695                         }
15696                         ndr->flags = _flags_save_string;
15697                 }
15698         }
15699         return NDR_ERR_SUCCESS;
15700 }
15701
15702 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15703 {
15704         uint32_t _ptr_port_name;
15705         TALLOC_CTX *_mem_save_port_name_0;
15706         if (ndr_flags & NDR_SCALARS) {
15707                 NDR_CHECK(ndr_pull_align(ndr, 4));
15708                 {
15709                         uint32_t _flags_save_string = ndr->flags;
15710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15712                         if (_ptr_port_name) {
15713                                 NDR_PULL_ALLOC(ndr, r->port_name);
15714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15715                         } else {
15716                                 r->port_name = NULL;
15717                         }
15718                         ndr->flags = _flags_save_string;
15719                 }
15720         }
15721         if (ndr_flags & NDR_BUFFERS) {
15722                 {
15723                         uint32_t _flags_save_string = ndr->flags;
15724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15725                         if (r->port_name) {
15726                                 uint32_t _relative_save_offset;
15727                                 _relative_save_offset = ndr->offset;
15728                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15729                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15730                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15731                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15732                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15733                                 ndr->offset = _relative_save_offset;
15734                         }
15735                         ndr->flags = _flags_save_string;
15736                 }
15737         }
15738         return NDR_ERR_SUCCESS;
15739 }
15740
15741 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15742 {
15743         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15744         ndr->depth++;
15745         ndr_print_ptr(ndr, "port_name", r->port_name);
15746         ndr->depth++;
15747         if (r->port_name) {
15748                 ndr_print_string(ndr, "port_name", r->port_name);
15749         }
15750         ndr->depth--;
15751         ndr->depth--;
15752 }
15753
15754 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15755 {
15756         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15757 }
15758
15759 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15760 {
15761         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15762         return NDR_ERR_SUCCESS;
15763 }
15764
15765 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15766 {
15767         uint32_t v;
15768         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15769         *r = v;
15770         return NDR_ERR_SUCCESS;
15771 }
15772
15773 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15774 {
15775         ndr_print_uint32(ndr, name, r);
15776         ndr->depth++;
15777         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15778         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15779         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15780         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15781         ndr->depth--;
15782 }
15783
15784 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15785 {
15786         if (ndr_flags & NDR_SCALARS) {
15787                 NDR_CHECK(ndr_push_align(ndr, 4));
15788                 {
15789                         uint32_t _flags_save_string = ndr->flags;
15790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15791                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15792                         ndr->flags = _flags_save_string;
15793                 }
15794                 {
15795                         uint32_t _flags_save_string = ndr->flags;
15796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15797                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15798                         ndr->flags = _flags_save_string;
15799                 }
15800                 {
15801                         uint32_t _flags_save_string = ndr->flags;
15802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15803                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15804                         ndr->flags = _flags_save_string;
15805                 }
15806                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15808         }
15809         if (ndr_flags & NDR_BUFFERS) {
15810                 {
15811                         uint32_t _flags_save_string = ndr->flags;
15812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15813                         if (r->port_name) {
15814                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15815                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15816                         }
15817                         ndr->flags = _flags_save_string;
15818                 }
15819                 {
15820                         uint32_t _flags_save_string = ndr->flags;
15821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15822                         if (r->monitor_name) {
15823                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15824                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15825                         }
15826                         ndr->flags = _flags_save_string;
15827                 }
15828                 {
15829                         uint32_t _flags_save_string = ndr->flags;
15830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15831                         if (r->description) {
15832                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15833                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15834                         }
15835                         ndr->flags = _flags_save_string;
15836                 }
15837         }
15838         return NDR_ERR_SUCCESS;
15839 }
15840
15841 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15842 {
15843         uint32_t _ptr_port_name;
15844         TALLOC_CTX *_mem_save_port_name_0;
15845         uint32_t _ptr_monitor_name;
15846         TALLOC_CTX *_mem_save_monitor_name_0;
15847         uint32_t _ptr_description;
15848         TALLOC_CTX *_mem_save_description_0;
15849         if (ndr_flags & NDR_SCALARS) {
15850                 NDR_CHECK(ndr_pull_align(ndr, 4));
15851                 {
15852                         uint32_t _flags_save_string = ndr->flags;
15853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15854                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15855                         if (_ptr_port_name) {
15856                                 NDR_PULL_ALLOC(ndr, r->port_name);
15857                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15858                         } else {
15859                                 r->port_name = NULL;
15860                         }
15861                         ndr->flags = _flags_save_string;
15862                 }
15863                 {
15864                         uint32_t _flags_save_string = ndr->flags;
15865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15866                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15867                         if (_ptr_monitor_name) {
15868                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15869                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15870                         } else {
15871                                 r->monitor_name = NULL;
15872                         }
15873                         ndr->flags = _flags_save_string;
15874                 }
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_description));
15879                         if (_ptr_description) {
15880                                 NDR_PULL_ALLOC(ndr, r->description);
15881                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15882                         } else {
15883                                 r->description = NULL;
15884                         }
15885                         ndr->flags = _flags_save_string;
15886                 }
15887                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15889         }
15890         if (ndr_flags & NDR_BUFFERS) {
15891                 {
15892                         uint32_t _flags_save_string = ndr->flags;
15893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15894                         if (r->port_name) {
15895                                 uint32_t _relative_save_offset;
15896                                 _relative_save_offset = ndr->offset;
15897                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15898                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15899                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15900                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15901                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15902                                 ndr->offset = _relative_save_offset;
15903                         }
15904                         ndr->flags = _flags_save_string;
15905                 }
15906                 {
15907                         uint32_t _flags_save_string = ndr->flags;
15908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15909                         if (r->monitor_name) {
15910                                 uint32_t _relative_save_offset;
15911                                 _relative_save_offset = ndr->offset;
15912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15913                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15914                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15917                                 ndr->offset = _relative_save_offset;
15918                         }
15919                         ndr->flags = _flags_save_string;
15920                 }
15921                 {
15922                         uint32_t _flags_save_string = ndr->flags;
15923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15924                         if (r->description) {
15925                                 uint32_t _relative_save_offset;
15926                                 _relative_save_offset = ndr->offset;
15927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15928                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15929                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15932                                 ndr->offset = _relative_save_offset;
15933                         }
15934                         ndr->flags = _flags_save_string;
15935                 }
15936         }
15937         return NDR_ERR_SUCCESS;
15938 }
15939
15940 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15941 {
15942         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15943         ndr->depth++;
15944         ndr_print_ptr(ndr, "port_name", r->port_name);
15945         ndr->depth++;
15946         if (r->port_name) {
15947                 ndr_print_string(ndr, "port_name", r->port_name);
15948         }
15949         ndr->depth--;
15950         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15951         ndr->depth++;
15952         if (r->monitor_name) {
15953                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15954         }
15955         ndr->depth--;
15956         ndr_print_ptr(ndr, "description", r->description);
15957         ndr->depth++;
15958         if (r->description) {
15959                 ndr_print_string(ndr, "description", r->description);
15960         }
15961         ndr->depth--;
15962         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15963         ndr_print_uint32(ndr, "reserved", r->reserved);
15964         ndr->depth--;
15965 }
15966
15967 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15968 {
15969         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15970 }
15971
15972 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15973 {
15974         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15975         return NDR_ERR_SUCCESS;
15976 }
15977
15978 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
15979 {
15980         uint32_t v;
15981         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15982         *r = v;
15983         return NDR_ERR_SUCCESS;
15984 }
15985
15986 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
15987 {
15988         const char *val = NULL;
15989
15990         switch (r) {
15991                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
15992                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
15993                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
15994                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
15995                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
15996                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
15997                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
15998                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
15999                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16000                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16001                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16002                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16003                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16004         }
16005         ndr_print_enum(ndr, name, "ENUM", val, r);
16006 }
16007
16008 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16009 {
16010         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16011         return NDR_ERR_SUCCESS;
16012 }
16013
16014 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16015 {
16016         uint32_t v;
16017         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16018         *r = v;
16019         return NDR_ERR_SUCCESS;
16020 }
16021
16022 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16023 {
16024         const char *val = NULL;
16025
16026         switch (r) {
16027                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16028                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16029                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16030         }
16031         ndr_print_enum(ndr, name, "ENUM", val, r);
16032 }
16033
16034 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16035 {
16036         if (ndr_flags & NDR_SCALARS) {
16037                 NDR_CHECK(ndr_push_align(ndr, 4));
16038                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16039                 {
16040                         uint32_t _flags_save_string = ndr->flags;
16041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16042                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16043                         ndr->flags = _flags_save_string;
16044                 }
16045                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16046         }
16047         if (ndr_flags & NDR_BUFFERS) {
16048                 {
16049                         uint32_t _flags_save_string = ndr->flags;
16050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16051                         if (r->status_string) {
16052                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16053                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16054                         }
16055                         ndr->flags = _flags_save_string;
16056                 }
16057         }
16058         return NDR_ERR_SUCCESS;
16059 }
16060
16061 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16062 {
16063         uint32_t _ptr_status_string;
16064         TALLOC_CTX *_mem_save_status_string_0;
16065         if (ndr_flags & NDR_SCALARS) {
16066                 NDR_CHECK(ndr_pull_align(ndr, 4));
16067                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16068                 {
16069                         uint32_t _flags_save_string = ndr->flags;
16070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16071                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16072                         if (_ptr_status_string) {
16073                                 NDR_PULL_ALLOC(ndr, r->status_string);
16074                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16075                         } else {
16076                                 r->status_string = NULL;
16077                         }
16078                         ndr->flags = _flags_save_string;
16079                 }
16080                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16081         }
16082         if (ndr_flags & NDR_BUFFERS) {
16083                 {
16084                         uint32_t _flags_save_string = ndr->flags;
16085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16086                         if (r->status_string) {
16087                                 uint32_t _relative_save_offset;
16088                                 _relative_save_offset = ndr->offset;
16089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16090                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16091                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16092                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16094                                 ndr->offset = _relative_save_offset;
16095                         }
16096                         ndr->flags = _flags_save_string;
16097                 }
16098         }
16099         return NDR_ERR_SUCCESS;
16100 }
16101
16102 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16103 {
16104         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16105         ndr->depth++;
16106         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16107         ndr_print_ptr(ndr, "status_string", r->status_string);
16108         ndr->depth++;
16109         if (r->status_string) {
16110                 ndr_print_string(ndr, "status_string", r->status_string);
16111         }
16112         ndr->depth--;
16113         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16114         ndr->depth--;
16115 }
16116
16117 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16118 {
16119         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16120 }
16121
16122 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16123 {
16124         if (ndr_flags & NDR_SCALARS) {
16125                 NDR_CHECK(ndr_push_align(ndr, 4));
16126                 {
16127                         uint32_t _flags_save_string = ndr->flags;
16128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16129                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16130                         ndr->flags = _flags_save_string;
16131                 }
16132                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16133         }
16134         if (ndr_flags & NDR_BUFFERS) {
16135                 {
16136                         uint32_t _flags_save_string = ndr->flags;
16137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16138                         if (r->port_name) {
16139                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16140                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16141                         }
16142                         ndr->flags = _flags_save_string;
16143                 }
16144         }
16145         return NDR_ERR_SUCCESS;
16146 }
16147
16148 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16149 {
16150         uint32_t _ptr_port_name;
16151         TALLOC_CTX *_mem_save_port_name_0;
16152         if (ndr_flags & NDR_SCALARS) {
16153                 NDR_CHECK(ndr_pull_align(ndr, 4));
16154                 {
16155                         uint32_t _flags_save_string = ndr->flags;
16156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16157                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16158                         if (_ptr_port_name) {
16159                                 NDR_PULL_ALLOC(ndr, r->port_name);
16160                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16161                         } else {
16162                                 r->port_name = NULL;
16163                         }
16164                         ndr->flags = _flags_save_string;
16165                 }
16166                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16167         }
16168         if (ndr_flags & NDR_BUFFERS) {
16169                 {
16170                         uint32_t _flags_save_string = ndr->flags;
16171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16172                         if (r->port_name) {
16173                                 uint32_t _relative_save_offset;
16174                                 _relative_save_offset = ndr->offset;
16175                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16176                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16177                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16178                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16179                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16180                                 ndr->offset = _relative_save_offset;
16181                         }
16182                         ndr->flags = _flags_save_string;
16183                 }
16184         }
16185         return NDR_ERR_SUCCESS;
16186 }
16187
16188 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16189 {
16190         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16191         ndr->depth++;
16192         ndr_print_ptr(ndr, "port_name", r->port_name);
16193         ndr->depth++;
16194         if (r->port_name) {
16195                 ndr_print_string(ndr, "port_name", r->port_name);
16196         }
16197         ndr->depth--;
16198         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16199         ndr->depth--;
16200 }
16201
16202 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16203 {
16204         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16205 }
16206
16207 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16208 {
16209         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16210         if (ndr_flags & NDR_SCALARS) {
16211                 int level = ndr_push_get_switch_value(ndr, r);
16212                 switch (level) {
16213                         case 1: {
16214                                 NDR_CHECK(ndr_push_align(ndr, 4));
16215                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16216                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16217                         break; }
16218
16219                         case 2: {
16220                                 NDR_CHECK(ndr_push_align(ndr, 4));
16221                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16222                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16223                         break; }
16224
16225                         case 3: {
16226                                 NDR_CHECK(ndr_push_align(ndr, 4));
16227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16228                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16229                         break; }
16230
16231                         case 0xff: {
16232                                 NDR_CHECK(ndr_push_align(ndr, 4));
16233                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16234                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16235                         break; }
16236
16237                         default: {
16238                         break; }
16239
16240                 }
16241         }
16242         if (ndr_flags & NDR_BUFFERS) {
16243                 int level = ndr_push_get_switch_value(ndr, r);
16244                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16245                 switch (level) {
16246                         case 1:
16247                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16248                         break;
16249
16250                         case 2:
16251                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16252                         break;
16253
16254                         case 3:
16255                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16256                         break;
16257
16258                         case 0xff:
16259                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16260                         break;
16261
16262                         default:
16263                         break;
16264
16265                 }
16266         }
16267         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16268         return NDR_ERR_SUCCESS;
16269 }
16270
16271 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16272 {
16273         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16274         int level;
16275         level = ndr_pull_get_switch_value(ndr, r);
16276         if (ndr_flags & NDR_SCALARS) {
16277                 switch (level) {
16278                         case 1: {
16279                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16280                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16281                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16282                         break; }
16283
16284                         case 2: {
16285                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16286                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16287                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16288                         break; }
16289
16290                         case 3: {
16291                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16292                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16293                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16294                         break; }
16295
16296                         case 0xff: {
16297                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16298                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16299                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16300                         break; }
16301
16302                         default: {
16303                         break; }
16304
16305                 }
16306         }
16307         if (ndr_flags & NDR_BUFFERS) {
16308                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16309                 switch (level) {
16310                         case 1:
16311                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16312                         break;
16313
16314                         case 2:
16315                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16316                         break;
16317
16318                         case 3:
16319                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16320                         break;
16321
16322                         case 0xff:
16323                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16324                         break;
16325
16326                         default:
16327                         break;
16328
16329                 }
16330         }
16331         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16332         return NDR_ERR_SUCCESS;
16333 }
16334
16335 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16336 {
16337         int level;
16338         level = ndr_print_get_switch_value(ndr, r);
16339         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16340         switch (level) {
16341                 case 1:
16342                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16343                 break;
16344
16345                 case 2:
16346                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16347                 break;
16348
16349                 case 3:
16350                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16351                 break;
16352
16353                 case 0xff:
16354                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16355                 break;
16356
16357                 default:
16358                 break;
16359
16360         }
16361 }
16362
16363 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16364 {
16365         if (ndr_flags & NDR_SCALARS) {
16366                 NDR_CHECK(ndr_push_align(ndr, 4));
16367                 {
16368                         uint32_t _flags_save_string = ndr->flags;
16369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16370                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16371                         ndr->flags = _flags_save_string;
16372                 }
16373         }
16374         if (ndr_flags & NDR_BUFFERS) {
16375                 {
16376                         uint32_t _flags_save_string = ndr->flags;
16377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16378                         if (r->monitor_name) {
16379                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16380                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16381                         }
16382                         ndr->flags = _flags_save_string;
16383                 }
16384         }
16385         return NDR_ERR_SUCCESS;
16386 }
16387
16388 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16389 {
16390         uint32_t _ptr_monitor_name;
16391         TALLOC_CTX *_mem_save_monitor_name_0;
16392         if (ndr_flags & NDR_SCALARS) {
16393                 NDR_CHECK(ndr_pull_align(ndr, 4));
16394                 {
16395                         uint32_t _flags_save_string = ndr->flags;
16396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16398                         if (_ptr_monitor_name) {
16399                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16401                         } else {
16402                                 r->monitor_name = NULL;
16403                         }
16404                         ndr->flags = _flags_save_string;
16405                 }
16406         }
16407         if (ndr_flags & NDR_BUFFERS) {
16408                 {
16409                         uint32_t _flags_save_string = ndr->flags;
16410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16411                         if (r->monitor_name) {
16412                                 uint32_t _relative_save_offset;
16413                                 _relative_save_offset = ndr->offset;
16414                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16415                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16416                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16417                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16418                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16419                                 ndr->offset = _relative_save_offset;
16420                         }
16421                         ndr->flags = _flags_save_string;
16422                 }
16423         }
16424         return NDR_ERR_SUCCESS;
16425 }
16426
16427 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16428 {
16429         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16430         ndr->depth++;
16431         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16432         ndr->depth++;
16433         if (r->monitor_name) {
16434                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16435         }
16436         ndr->depth--;
16437         ndr->depth--;
16438 }
16439
16440 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16441 {
16442         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16443 }
16444
16445 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16446 {
16447         if (ndr_flags & NDR_SCALARS) {
16448                 NDR_CHECK(ndr_push_align(ndr, 4));
16449                 {
16450                         uint32_t _flags_save_string = ndr->flags;
16451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16452                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16453                         ndr->flags = _flags_save_string;
16454                 }
16455                 {
16456                         uint32_t _flags_save_string = ndr->flags;
16457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16458                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16459                         ndr->flags = _flags_save_string;
16460                 }
16461                 {
16462                         uint32_t _flags_save_string = ndr->flags;
16463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16464                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16465                         ndr->flags = _flags_save_string;
16466                 }
16467         }
16468         if (ndr_flags & NDR_BUFFERS) {
16469                 {
16470                         uint32_t _flags_save_string = ndr->flags;
16471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16472                         if (r->monitor_name) {
16473                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16474                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16475                         }
16476                         ndr->flags = _flags_save_string;
16477                 }
16478                 {
16479                         uint32_t _flags_save_string = ndr->flags;
16480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16481                         if (r->environment) {
16482                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16483                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16484                         }
16485                         ndr->flags = _flags_save_string;
16486                 }
16487                 {
16488                         uint32_t _flags_save_string = ndr->flags;
16489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16490                         if (r->dll_name) {
16491                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16492                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16493                         }
16494                         ndr->flags = _flags_save_string;
16495                 }
16496         }
16497         return NDR_ERR_SUCCESS;
16498 }
16499
16500 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16501 {
16502         uint32_t _ptr_monitor_name;
16503         TALLOC_CTX *_mem_save_monitor_name_0;
16504         uint32_t _ptr_environment;
16505         TALLOC_CTX *_mem_save_environment_0;
16506         uint32_t _ptr_dll_name;
16507         TALLOC_CTX *_mem_save_dll_name_0;
16508         if (ndr_flags & NDR_SCALARS) {
16509                 NDR_CHECK(ndr_pull_align(ndr, 4));
16510                 {
16511                         uint32_t _flags_save_string = ndr->flags;
16512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16514                         if (_ptr_monitor_name) {
16515                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16517                         } else {
16518                                 r->monitor_name = NULL;
16519                         }
16520                         ndr->flags = _flags_save_string;
16521                 }
16522                 {
16523                         uint32_t _flags_save_string = ndr->flags;
16524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16526                         if (_ptr_environment) {
16527                                 NDR_PULL_ALLOC(ndr, r->environment);
16528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16529                         } else {
16530                                 r->environment = NULL;
16531                         }
16532                         ndr->flags = _flags_save_string;
16533                 }
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_dll_name));
16538                         if (_ptr_dll_name) {
16539                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16541                         } else {
16542                                 r->dll_name = NULL;
16543                         }
16544                         ndr->flags = _flags_save_string;
16545                 }
16546         }
16547         if (ndr_flags & NDR_BUFFERS) {
16548                 {
16549                         uint32_t _flags_save_string = ndr->flags;
16550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16551                         if (r->monitor_name) {
16552                                 uint32_t _relative_save_offset;
16553                                 _relative_save_offset = ndr->offset;
16554                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16555                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16556                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16557                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16558                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16559                                 ndr->offset = _relative_save_offset;
16560                         }
16561                         ndr->flags = _flags_save_string;
16562                 }
16563                 {
16564                         uint32_t _flags_save_string = ndr->flags;
16565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16566                         if (r->environment) {
16567                                 uint32_t _relative_save_offset;
16568                                 _relative_save_offset = ndr->offset;
16569                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16570                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16571                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16572                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16573                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16574                                 ndr->offset = _relative_save_offset;
16575                         }
16576                         ndr->flags = _flags_save_string;
16577                 }
16578                 {
16579                         uint32_t _flags_save_string = ndr->flags;
16580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16581                         if (r->dll_name) {
16582                                 uint32_t _relative_save_offset;
16583                                 _relative_save_offset = ndr->offset;
16584                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16585                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16586                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16587                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16588                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16589                                 ndr->offset = _relative_save_offset;
16590                         }
16591                         ndr->flags = _flags_save_string;
16592                 }
16593         }
16594         return NDR_ERR_SUCCESS;
16595 }
16596
16597 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16598 {
16599         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16600         ndr->depth++;
16601         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16602         ndr->depth++;
16603         if (r->monitor_name) {
16604                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16605         }
16606         ndr->depth--;
16607         ndr_print_ptr(ndr, "environment", r->environment);
16608         ndr->depth++;
16609         if (r->environment) {
16610                 ndr_print_string(ndr, "environment", r->environment);
16611         }
16612         ndr->depth--;
16613         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16614         ndr->depth++;
16615         if (r->dll_name) {
16616                 ndr_print_string(ndr, "dll_name", r->dll_name);
16617         }
16618         ndr->depth--;
16619         ndr->depth--;
16620 }
16621
16622 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16623 {
16624         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16625 }
16626
16627 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16628 {
16629         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16630         if (ndr_flags & NDR_SCALARS) {
16631                 int level = ndr_push_get_switch_value(ndr, r);
16632                 switch (level) {
16633                         case 1: {
16634                                 NDR_CHECK(ndr_push_align(ndr, 4));
16635                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16636                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16637                         break; }
16638
16639                         case 2: {
16640                                 NDR_CHECK(ndr_push_align(ndr, 4));
16641                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16642                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16643                         break; }
16644
16645                         default: {
16646                         break; }
16647
16648                 }
16649         }
16650         if (ndr_flags & NDR_BUFFERS) {
16651                 int level = ndr_push_get_switch_value(ndr, r);
16652                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16653                 switch (level) {
16654                         case 1:
16655                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16656                         break;
16657
16658                         case 2:
16659                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16660                         break;
16661
16662                         default:
16663                         break;
16664
16665                 }
16666         }
16667         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16668         return NDR_ERR_SUCCESS;
16669 }
16670
16671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16672 {
16673         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16674         int level;
16675         level = ndr_pull_get_switch_value(ndr, r);
16676         if (ndr_flags & NDR_SCALARS) {
16677                 switch (level) {
16678                         case 1: {
16679                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16680                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16681                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16682                         break; }
16683
16684                         case 2: {
16685                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16686                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16687                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16688                         break; }
16689
16690                         default: {
16691                         break; }
16692
16693                 }
16694         }
16695         if (ndr_flags & NDR_BUFFERS) {
16696                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16697                 switch (level) {
16698                         case 1:
16699                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16700                         break;
16701
16702                         case 2:
16703                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16704                         break;
16705
16706                         default:
16707                         break;
16708
16709                 }
16710         }
16711         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16712         return NDR_ERR_SUCCESS;
16713 }
16714
16715 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16716 {
16717         int level;
16718         level = ndr_print_get_switch_value(ndr, r);
16719         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16720         switch (level) {
16721                 case 1:
16722                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16723                 break;
16724
16725                 case 2:
16726                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16727                 break;
16728
16729                 default:
16730                 break;
16731
16732         }
16733 }
16734
16735 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16736 {
16737         if (ndr_flags & NDR_SCALARS) {
16738                 NDR_CHECK(ndr_push_align(ndr, 4));
16739                 {
16740                         uint32_t _flags_save_string = ndr->flags;
16741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16742                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16743                         ndr->flags = _flags_save_string;
16744                 }
16745         }
16746         if (ndr_flags & NDR_BUFFERS) {
16747                 {
16748                         uint32_t _flags_save_string = ndr->flags;
16749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16750                         if (r->name_array) {
16751                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16752                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16753                         }
16754                         ndr->flags = _flags_save_string;
16755                 }
16756         }
16757         return NDR_ERR_SUCCESS;
16758 }
16759
16760 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16761 {
16762         uint32_t _ptr_name_array;
16763         TALLOC_CTX *_mem_save_name_array_0;
16764         if (ndr_flags & NDR_SCALARS) {
16765                 NDR_CHECK(ndr_pull_align(ndr, 4));
16766                 {
16767                         uint32_t _flags_save_string = ndr->flags;
16768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16769                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16770                         if (_ptr_name_array) {
16771                                 NDR_PULL_ALLOC(ndr, r->name_array);
16772                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16773                         } else {
16774                                 r->name_array = NULL;
16775                         }
16776                         ndr->flags = _flags_save_string;
16777                 }
16778         }
16779         if (ndr_flags & NDR_BUFFERS) {
16780                 {
16781                         uint32_t _flags_save_string = ndr->flags;
16782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16783                         if (r->name_array) {
16784                                 uint32_t _relative_save_offset;
16785                                 _relative_save_offset = ndr->offset;
16786                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16787                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16788                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16789                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16790                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16791                                 ndr->offset = _relative_save_offset;
16792                         }
16793                         ndr->flags = _flags_save_string;
16794                 }
16795         }
16796         return NDR_ERR_SUCCESS;
16797 }
16798
16799 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16800 {
16801         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16802         ndr->depth++;
16803         ndr_print_ptr(ndr, "name_array", r->name_array);
16804         ndr->depth++;
16805         if (r->name_array) {
16806                 ndr_print_string(ndr, "name_array", r->name_array);
16807         }
16808         ndr->depth--;
16809         ndr->depth--;
16810 }
16811
16812 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16813 {
16814         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16815 }
16816
16817 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16818 {
16819         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16820         if (ndr_flags & NDR_SCALARS) {
16821                 int level = ndr_push_get_switch_value(ndr, r);
16822                 switch (level) {
16823                         case 1: {
16824                                 NDR_CHECK(ndr_push_align(ndr, 4));
16825                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16826                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16827                         break; }
16828
16829                         default: {
16830                         break; }
16831
16832                 }
16833         }
16834         if (ndr_flags & NDR_BUFFERS) {
16835                 int level = ndr_push_get_switch_value(ndr, r);
16836                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16837                 switch (level) {
16838                         case 1:
16839                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16840                         break;
16841
16842                         default:
16843                         break;
16844
16845                 }
16846         }
16847         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16848         return NDR_ERR_SUCCESS;
16849 }
16850
16851 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16852 {
16853         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16854         int level;
16855         level = ndr_pull_get_switch_value(ndr, r);
16856         if (ndr_flags & NDR_SCALARS) {
16857                 switch (level) {
16858                         case 1: {
16859                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16860                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16861                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16862                         break; }
16863
16864                         default: {
16865                         break; }
16866
16867                 }
16868         }
16869         if (ndr_flags & NDR_BUFFERS) {
16870                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16871                 switch (level) {
16872                         case 1:
16873                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16874                         break;
16875
16876                         default:
16877                         break;
16878
16879                 }
16880         }
16881         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16882         return NDR_ERR_SUCCESS;
16883 }
16884
16885 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16886 {
16887         int level;
16888         level = ndr_print_get_switch_value(ndr, r);
16889         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16890         switch (level) {
16891                 case 1:
16892                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16893                 break;
16894
16895                 default:
16896                 break;
16897
16898         }
16899 }
16900
16901 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16902 {
16903         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16904         return NDR_ERR_SUCCESS;
16905 }
16906
16907 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16908 {
16909         uint32_t v;
16910         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16911         *r = v;
16912         return NDR_ERR_SUCCESS;
16913 }
16914
16915 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16916 {
16917         ndr_print_uint32(ndr, name, r);
16918         ndr->depth++;
16919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16923         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16924         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16925         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16926         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16927         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16928         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16929         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16930         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16931         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16932         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16933         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16934         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16935         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16936         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16937         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16938         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16940         ndr->depth--;
16941 }
16942
16943 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16944 {
16945         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16946         return NDR_ERR_SUCCESS;
16947 }
16948
16949 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16950 {
16951         uint16_t v;
16952         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16953         *r = v;
16954         return NDR_ERR_SUCCESS;
16955 }
16956
16957 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16958 {
16959         const char *val = NULL;
16960
16961         switch (r) {
16962                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16963                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16964                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16965                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16966                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16967                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16968                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16969                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16970                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16971                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16972                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16973                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16974                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16975                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
16976                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
16977                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
16978                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
16979                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
16980                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
16981                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
16982                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
16983                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
16984                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
16985                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
16986                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
16987                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
16988         }
16989         ndr_print_enum(ndr, name, "ENUM", val, r);
16990 }
16991
16992 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
16993 {
16994         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16995         return NDR_ERR_SUCCESS;
16996 }
16997
16998 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
16999 {
17000         uint16_t v;
17001         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17002         *r = v;
17003         return NDR_ERR_SUCCESS;
17004 }
17005
17006 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17007 {
17008         const char *val = NULL;
17009
17010         switch (r) {
17011                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
17012                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
17013         }
17014         ndr_print_enum(ndr, name, "ENUM", val, r);
17015 }
17016
17017 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17018 {
17019         uint32_t cntr_fields_1;
17020         if (ndr_flags & NDR_SCALARS) {
17021                 NDR_CHECK(ndr_push_align(ndr, 4));
17022                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17023                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17028         }
17029         if (ndr_flags & NDR_BUFFERS) {
17030                 if (r->fields) {
17031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17032                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17033                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
17034                         }
17035                 }
17036         }
17037         return NDR_ERR_SUCCESS;
17038 }
17039
17040 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17041 {
17042         uint32_t _ptr_fields;
17043         uint32_t cntr_fields_1;
17044         TALLOC_CTX *_mem_save_fields_0;
17045         TALLOC_CTX *_mem_save_fields_1;
17046         if (ndr_flags & NDR_SCALARS) {
17047                 NDR_CHECK(ndr_pull_align(ndr, 4));
17048                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17049                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17054                 if (_ptr_fields) {
17055                         NDR_PULL_ALLOC(ndr, r->fields);
17056                 } else {
17057                         r->fields = NULL;
17058                 }
17059         }
17060         if (ndr_flags & NDR_BUFFERS) {
17061                 if (r->fields) {
17062                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17063                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17064                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17065                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17066                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17067                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17068                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17069                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17070                         }
17071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17073                 }
17074                 if (r->fields) {
17075                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17076                 }
17077         }
17078         return NDR_ERR_SUCCESS;
17079 }
17080
17081 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17082 {
17083         uint32_t cntr_fields_1;
17084         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17085         ndr->depth++;
17086         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17087         ndr_print_uint16(ndr, "u1", r->u1);
17088         ndr_print_uint32(ndr, "u2", r->u2);
17089         ndr_print_uint32(ndr, "u3", r->u3);
17090         ndr_print_uint32(ndr, "count", r->count);
17091         ndr_print_ptr(ndr, "fields", r->fields);
17092         ndr->depth++;
17093         if (r->fields) {
17094                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17095                 ndr->depth++;
17096                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17097                         char *idx_1=NULL;
17098                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17099                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17100                                 free(idx_1);
17101                         }
17102                 }
17103                 ndr->depth--;
17104         }
17105         ndr->depth--;
17106         ndr->depth--;
17107 }
17108
17109 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17110 {
17111         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17112         return NDR_ERR_SUCCESS;
17113 }
17114
17115 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17116 {
17117         uint32_t v;
17118         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17119         *r = v;
17120         return NDR_ERR_SUCCESS;
17121 }
17122
17123 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17124 {
17125         ndr_print_uint32(ndr, name, r);
17126         ndr->depth++;
17127         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17128         ndr->depth--;
17129 }
17130
17131 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17132 {
17133         uint32_t cntr_types_1;
17134         if (ndr_flags & NDR_SCALARS) {
17135                 NDR_CHECK(ndr_push_align(ndr, 4));
17136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17137                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17140         }
17141         if (ndr_flags & NDR_BUFFERS) {
17142                 if (r->types) {
17143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17144                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17145                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17146                         }
17147                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17148                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17149                         }
17150                 }
17151         }
17152         return NDR_ERR_SUCCESS;
17153 }
17154
17155 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17156 {
17157         uint32_t _ptr_types;
17158         uint32_t cntr_types_1;
17159         TALLOC_CTX *_mem_save_types_0;
17160         TALLOC_CTX *_mem_save_types_1;
17161         if (ndr_flags & NDR_SCALARS) {
17162                 NDR_CHECK(ndr_pull_align(ndr, 4));
17163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17164                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17167                 if (_ptr_types) {
17168                         NDR_PULL_ALLOC(ndr, r->types);
17169                 } else {
17170                         r->types = NULL;
17171                 }
17172         }
17173         if (ndr_flags & NDR_BUFFERS) {
17174                 if (r->types) {
17175                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17176                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17178                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17179                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17180                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17181                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17182                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17183                         }
17184                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17185                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17186                         }
17187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17189                 }
17190                 if (r->types) {
17191                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17192                 }
17193         }
17194         return NDR_ERR_SUCCESS;
17195 }
17196
17197 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17198 {
17199         uint32_t cntr_types_1;
17200         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17201         ndr->depth++;
17202         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17203         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17204         ndr_print_uint32(ndr, "count", r->count);
17205         ndr_print_ptr(ndr, "types", r->types);
17206         ndr->depth++;
17207         if (r->types) {
17208                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17209                 ndr->depth++;
17210                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17211                         char *idx_1=NULL;
17212                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17213                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17214                                 free(idx_1);
17215                         }
17216                 }
17217                 ndr->depth--;
17218         }
17219         ndr->depth--;
17220         ndr->depth--;
17221 }
17222
17223 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17224 {
17225         if (ndr_flags & NDR_SCALARS) {
17226                 NDR_CHECK(ndr_push_align(ndr, 4));
17227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17229         }
17230         if (ndr_flags & NDR_BUFFERS) {
17231                 if (r->string) {
17232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17233                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17234                 }
17235         }
17236         return NDR_ERR_SUCCESS;
17237 }
17238
17239 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17240 {
17241         uint32_t _ptr_string;
17242         TALLOC_CTX *_mem_save_string_0;
17243         if (ndr_flags & NDR_SCALARS) {
17244                 NDR_CHECK(ndr_pull_align(ndr, 4));
17245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17246                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17247                 if (_ptr_string) {
17248                         NDR_PULL_ALLOC(ndr, r->string);
17249                 } else {
17250                         r->string = NULL;
17251                 }
17252         }
17253         if (ndr_flags & NDR_BUFFERS) {
17254                 if (r->string) {
17255                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17256                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17258                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17260                 }
17261                 if (r->string) {
17262                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17263                 }
17264         }
17265         return NDR_ERR_SUCCESS;
17266 }
17267
17268 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17269 {
17270         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17271         ndr->depth++;
17272         ndr_print_uint32(ndr, "size", r->size);
17273         ndr_print_ptr(ndr, "string", r->string);
17274         ndr->depth++;
17275         if (r->string) {
17276                 ndr_print_string(ndr, "string", r->string);
17277         }
17278         ndr->depth--;
17279         ndr->depth--;
17280 }
17281
17282 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17283 {
17284         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17285         return NDR_ERR_SUCCESS;
17286 }
17287
17288 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17289 {
17290         uint32_t v;
17291         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17292         *r = v;
17293         return NDR_ERR_SUCCESS;
17294 }
17295
17296 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17297 {
17298         const char *val = NULL;
17299
17300         switch (r) {
17301                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17302                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17303                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17304                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17305                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17306         }
17307         ndr_print_enum(ndr, name, "ENUM", val, r);
17308 }
17309
17310 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17311 {
17312         if (ndr_flags & NDR_SCALARS) {
17313                 int level = ndr_push_get_switch_value(ndr, r);
17314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17315                 switch (level) {
17316                         case 1: {
17317                                 uint32_t cntr_integer_0;
17318                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17319                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17320                                 }
17321                         break; }
17322
17323                         case 2: {
17324                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17325                         break; }
17326
17327                         case 3: {
17328                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17329                         break; }
17330
17331                         case 4: {
17332                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17333                         break; }
17334
17335                         case 5: {
17336                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17337                         break; }
17338
17339                         default:
17340                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17341                 }
17342         }
17343         if (ndr_flags & NDR_BUFFERS) {
17344                 int level = ndr_push_get_switch_value(ndr, r);
17345                 switch (level) {
17346                         case 1:
17347                         break;
17348
17349                         case 2:
17350                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17351                         break;
17352
17353                         case 3:
17354                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17355                         break;
17356
17357                         case 4:
17358                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17359                         break;
17360
17361                         case 5:
17362                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17363                         break;
17364
17365                         default:
17366                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17367                 }
17368         }
17369         return NDR_ERR_SUCCESS;
17370 }
17371
17372 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17373 {
17374         int level;
17375         uint32_t _level;
17376         level = ndr_pull_get_switch_value(ndr, r);
17377         if (ndr_flags & NDR_SCALARS) {
17378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17379                 if (_level != level) {
17380                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17381                 }
17382                 switch (level) {
17383                         case 1: {
17384                                 uint32_t cntr_integer_0;
17385                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17386                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17387                                 }
17388                         break; }
17389
17390                         case 2: {
17391                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17392                         break; }
17393
17394                         case 3: {
17395                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17396                         break; }
17397
17398                         case 4: {
17399                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17400                         break; }
17401
17402                         case 5: {
17403                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17404                         break; }
17405
17406                         default:
17407                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17408                 }
17409         }
17410         if (ndr_flags & NDR_BUFFERS) {
17411                 switch (level) {
17412                         case 1:
17413                         break;
17414
17415                         case 2:
17416                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17417                         break;
17418
17419                         case 3:
17420                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17421                         break;
17422
17423                         case 4:
17424                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17425                         break;
17426
17427                         case 5:
17428                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17429                         break;
17430
17431                         default:
17432                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17433                 }
17434         }
17435         return NDR_ERR_SUCCESS;
17436 }
17437
17438 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17439 {
17440         int level;
17441         uint32_t cntr_integer_0;
17442         level = ndr_print_get_switch_value(ndr, r);
17443         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17444         switch (level) {
17445                 case 1:
17446                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17447                         ndr->depth++;
17448                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17449                                 char *idx_0=NULL;
17450                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17451                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17452                                         free(idx_0);
17453                                 }
17454                         }
17455                         ndr->depth--;
17456                 break;
17457
17458                 case 2:
17459                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17460                 break;
17461
17462                 case 3:
17463                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17464                 break;
17465
17466                 case 4:
17467                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17468                 break;
17469
17470                 case 5:
17471                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17472                 break;
17473
17474                 default:
17475                         ndr_print_bad_level(ndr, name, level);
17476         }
17477 }
17478
17479 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17480 {
17481         if (ndr_flags & NDR_SCALARS) {
17482                 NDR_CHECK(ndr_push_align(ndr, 4));
17483                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17484                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17485                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17487                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17488                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17489         }
17490         if (ndr_flags & NDR_BUFFERS) {
17491                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17492         }
17493         return NDR_ERR_SUCCESS;
17494 }
17495
17496 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17497 {
17498         if (ndr_flags & NDR_SCALARS) {
17499                 NDR_CHECK(ndr_pull_align(ndr, 4));
17500                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17501                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17502                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17504                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17505                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17506         }
17507         if (ndr_flags & NDR_BUFFERS) {
17508                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17509         }
17510         return NDR_ERR_SUCCESS;
17511 }
17512
17513 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17514 {
17515         ndr_print_struct(ndr, name, "spoolss_Notify");
17516         ndr->depth++;
17517         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17518         ndr_print_spoolss_Field(ndr, "field", r->field);
17519         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17520         ndr_print_uint32(ndr, "job_id", r->job_id);
17521         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17522         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17523         ndr->depth--;
17524 }
17525
17526 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17527 {
17528         uint32_t cntr_notifies_0;
17529         if (ndr_flags & NDR_SCALARS) {
17530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17531                 NDR_CHECK(ndr_push_align(ndr, 4));
17532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17535                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17536                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17537                 }
17538         }
17539         if (ndr_flags & NDR_BUFFERS) {
17540                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17541                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17542                 }
17543         }
17544         return NDR_ERR_SUCCESS;
17545 }
17546
17547 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17548 {
17549         uint32_t cntr_notifies_0;
17550         TALLOC_CTX *_mem_save_notifies_0;
17551         if (ndr_flags & NDR_SCALARS) {
17552                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17553                 NDR_CHECK(ndr_pull_align(ndr, 4));
17554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17557                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17558                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17559                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17560                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17561                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17562                 }
17563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17564                 if (r->notifies) {
17565                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17566                 }
17567         }
17568         if (ndr_flags & NDR_BUFFERS) {
17569                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17570                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17571                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17572                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17573                 }
17574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17575         }
17576         return NDR_ERR_SUCCESS;
17577 }
17578
17579 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17580 {
17581         uint32_t cntr_notifies_0;
17582         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17583         ndr->depth++;
17584         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17585         ndr_print_uint32(ndr, "flags", r->flags);
17586         ndr_print_uint32(ndr, "count", r->count);
17587         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17588         ndr->depth++;
17589         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17590                 char *idx_0=NULL;
17591                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17592                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17593                         free(idx_0);
17594                 }
17595         }
17596         ndr->depth--;
17597         ndr->depth--;
17598 }
17599
17600 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17601 {
17602         if (ndr_flags & NDR_SCALARS) {
17603                 int level = ndr_push_get_switch_value(ndr, r);
17604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17605                 switch (level) {
17606                         case 0: {
17607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17608                         break; }
17609
17610                         default:
17611                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17612                 }
17613         }
17614         if (ndr_flags & NDR_BUFFERS) {
17615                 int level = ndr_push_get_switch_value(ndr, r);
17616                 switch (level) {
17617                         case 0:
17618                                 if (r->info0) {
17619                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17620                                 }
17621                         break;
17622
17623                         default:
17624                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17625                 }
17626         }
17627         return NDR_ERR_SUCCESS;
17628 }
17629
17630 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17631 {
17632         int level;
17633         uint32_t _level;
17634         TALLOC_CTX *_mem_save_info0_0;
17635         level = ndr_pull_get_switch_value(ndr, r);
17636         if (ndr_flags & NDR_SCALARS) {
17637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17638                 if (_level != level) {
17639                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17640                 }
17641                 switch (level) {
17642                         case 0: {
17643                                 uint32_t _ptr_info0;
17644                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17645                                 if (_ptr_info0) {
17646                                         NDR_PULL_ALLOC(ndr, r->info0);
17647                                 } else {
17648                                         r->info0 = NULL;
17649                                 }
17650                         break; }
17651
17652                         default:
17653                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17654                 }
17655         }
17656         if (ndr_flags & NDR_BUFFERS) {
17657                 switch (level) {
17658                         case 0:
17659                                 if (r->info0) {
17660                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17661                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17662                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17663                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17664                                 }
17665                         break;
17666
17667                         default:
17668                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17669                 }
17670         }
17671         return NDR_ERR_SUCCESS;
17672 }
17673
17674 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17675 {
17676         int level;
17677         level = ndr_print_get_switch_value(ndr, r);
17678         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17679         switch (level) {
17680                 case 0:
17681                         ndr_print_ptr(ndr, "info0", r->info0);
17682                         ndr->depth++;
17683                         if (r->info0) {
17684                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17685                         }
17686                         ndr->depth--;
17687                 break;
17688
17689                 default:
17690                         ndr_print_bad_level(ndr, name, level);
17691         }
17692 }
17693
17694 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17695 {
17696         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17697         return NDR_ERR_SUCCESS;
17698 }
17699
17700 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17701 {
17702         uint32_t v;
17703         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17704         *r = v;
17705         return NDR_ERR_SUCCESS;
17706 }
17707
17708 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17709 {
17710         ndr_print_uint32(ndr, name, r);
17711         ndr->depth++;
17712         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17713         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17714         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17715         ndr->depth--;
17716 }
17717
17718 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17719 {
17720         if (ndr_flags & NDR_SCALARS) {
17721                 NDR_CHECK(ndr_push_align(ndr, 4));
17722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17726                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17727                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17728                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17729         }
17730         if (ndr_flags & NDR_BUFFERS) {
17731                 if (r->client) {
17732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17736                 }
17737                 if (r->user) {
17738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17742                 }
17743         }
17744         return NDR_ERR_SUCCESS;
17745 }
17746
17747 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17748 {
17749         uint32_t _ptr_client;
17750         TALLOC_CTX *_mem_save_client_0;
17751         uint32_t _ptr_user;
17752         TALLOC_CTX *_mem_save_user_0;
17753         if (ndr_flags & NDR_SCALARS) {
17754                 NDR_CHECK(ndr_pull_align(ndr, 4));
17755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17757                 if (_ptr_client) {
17758                         NDR_PULL_ALLOC(ndr, r->client);
17759                 } else {
17760                         r->client = NULL;
17761                 }
17762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17763                 if (_ptr_user) {
17764                         NDR_PULL_ALLOC(ndr, r->user);
17765                 } else {
17766                         r->user = NULL;
17767                 }
17768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17769                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17770                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17771                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17772         }
17773         if (ndr_flags & NDR_BUFFERS) {
17774                 if (r->client) {
17775                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17776                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17779                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17780                                 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));
17781                         }
17782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17785                 }
17786                 if (r->user) {
17787                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17788                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17791                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17792                                 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));
17793                         }
17794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17797                 }
17798         }
17799         return NDR_ERR_SUCCESS;
17800 }
17801
17802 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17803 {
17804         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17805         ndr->depth++;
17806         ndr_print_uint32(ndr, "size", r->size);
17807         ndr_print_ptr(ndr, "client", r->client);
17808         ndr->depth++;
17809         if (r->client) {
17810                 ndr_print_string(ndr, "client", r->client);
17811         }
17812         ndr->depth--;
17813         ndr_print_ptr(ndr, "user", r->user);
17814         ndr->depth++;
17815         if (r->user) {
17816                 ndr_print_string(ndr, "user", r->user);
17817         }
17818         ndr->depth--;
17819         ndr_print_uint32(ndr, "build", r->build);
17820         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17821         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17822         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17823         ndr->depth--;
17824 }
17825
17826 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17827 {
17828         if (ndr_flags & NDR_SCALARS) {
17829                 NDR_CHECK(ndr_push_align(ndr, 4));
17830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17831         }
17832         if (ndr_flags & NDR_BUFFERS) {
17833         }
17834         return NDR_ERR_SUCCESS;
17835 }
17836
17837 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17838 {
17839         if (ndr_flags & NDR_SCALARS) {
17840                 NDR_CHECK(ndr_pull_align(ndr, 4));
17841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17842         }
17843         if (ndr_flags & NDR_BUFFERS) {
17844         }
17845         return NDR_ERR_SUCCESS;
17846 }
17847
17848 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17849 {
17850         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17851         ndr->depth++;
17852         ndr_print_uint32(ndr, "not_used", r->not_used);
17853         ndr->depth--;
17854 }
17855
17856 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17857 {
17858         if (ndr_flags & NDR_SCALARS) {
17859                 NDR_CHECK(ndr_push_align(ndr, 4));
17860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17866                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17867                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17868                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17869                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17870         }
17871         if (ndr_flags & NDR_BUFFERS) {
17872                 if (r->client) {
17873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17876                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17877                 }
17878                 if (r->user) {
17879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17883                 }
17884         }
17885         return NDR_ERR_SUCCESS;
17886 }
17887
17888 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17889 {
17890         uint32_t _ptr_client;
17891         TALLOC_CTX *_mem_save_client_0;
17892         uint32_t _ptr_user;
17893         TALLOC_CTX *_mem_save_user_0;
17894         if (ndr_flags & NDR_SCALARS) {
17895                 NDR_CHECK(ndr_pull_align(ndr, 4));
17896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17900                 if (_ptr_client) {
17901                         NDR_PULL_ALLOC(ndr, r->client);
17902                 } else {
17903                         r->client = NULL;
17904                 }
17905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17906                 if (_ptr_user) {
17907                         NDR_PULL_ALLOC(ndr, r->user);
17908                 } else {
17909                         r->user = NULL;
17910                 }
17911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17912                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17913                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17914                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17915                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17916         }
17917         if (ndr_flags & NDR_BUFFERS) {
17918                 if (r->client) {
17919                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17920                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17923                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17924                                 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));
17925                         }
17926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17929                 }
17930                 if (r->user) {
17931                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17932                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17935                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17936                                 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));
17937                         }
17938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17941                 }
17942         }
17943         return NDR_ERR_SUCCESS;
17944 }
17945
17946 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17947 {
17948         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17949         ndr->depth++;
17950         ndr_print_uint32(ndr, "size", r->size);
17951         ndr_print_uint32(ndr, "flags", r->flags);
17952         ndr_print_uint32(ndr, "size2", r->size2);
17953         ndr_print_ptr(ndr, "client", r->client);
17954         ndr->depth++;
17955         if (r->client) {
17956                 ndr_print_string(ndr, "client", r->client);
17957         }
17958         ndr->depth--;
17959         ndr_print_ptr(ndr, "user", r->user);
17960         ndr->depth++;
17961         if (r->user) {
17962                 ndr_print_string(ndr, "user", r->user);
17963         }
17964         ndr->depth--;
17965         ndr_print_uint32(ndr, "build", r->build);
17966         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17967         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17968         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17969         ndr_print_udlong(ndr, "reserved", r->reserved);
17970         ndr->depth--;
17971 }
17972
17973 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17974 {
17975         if (ndr_flags & NDR_SCALARS) {
17976                 int level = ndr_push_get_switch_value(ndr, r);
17977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17978                 switch (level) {
17979                         case 1: {
17980                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
17981                         break; }
17982
17983                         case 2: {
17984                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
17985                         break; }
17986
17987                         case 3: {
17988                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
17989                         break; }
17990
17991                         default:
17992                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17993                 }
17994         }
17995         if (ndr_flags & NDR_BUFFERS) {
17996                 int level = ndr_push_get_switch_value(ndr, r);
17997                 switch (level) {
17998                         case 1:
17999                                 if (r->level1) {
18000                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18001                                 }
18002                         break;
18003
18004                         case 2:
18005                                 if (r->level2) {
18006                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18007                                 }
18008                         break;
18009
18010                         case 3:
18011                                 if (r->level3) {
18012                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18013                                 }
18014                         break;
18015
18016                         default:
18017                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18018                 }
18019         }
18020         return NDR_ERR_SUCCESS;
18021 }
18022
18023 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18024 {
18025         int level;
18026         uint32_t _level;
18027         TALLOC_CTX *_mem_save_level1_0;
18028         TALLOC_CTX *_mem_save_level2_0;
18029         TALLOC_CTX *_mem_save_level3_0;
18030         level = ndr_pull_get_switch_value(ndr, r);
18031         if (ndr_flags & NDR_SCALARS) {
18032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18033                 if (_level != level) {
18034                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18035                 }
18036                 switch (level) {
18037                         case 1: {
18038                                 uint32_t _ptr_level1;
18039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18040                                 if (_ptr_level1) {
18041                                         NDR_PULL_ALLOC(ndr, r->level1);
18042                                 } else {
18043                                         r->level1 = NULL;
18044                                 }
18045                         break; }
18046
18047                         case 2: {
18048                                 uint32_t _ptr_level2;
18049                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18050                                 if (_ptr_level2) {
18051                                         NDR_PULL_ALLOC(ndr, r->level2);
18052                                 } else {
18053                                         r->level2 = NULL;
18054                                 }
18055                         break; }
18056
18057                         case 3: {
18058                                 uint32_t _ptr_level3;
18059                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18060                                 if (_ptr_level3) {
18061                                         NDR_PULL_ALLOC(ndr, r->level3);
18062                                 } else {
18063                                         r->level3 = NULL;
18064                                 }
18065                         break; }
18066
18067                         default:
18068                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18069                 }
18070         }
18071         if (ndr_flags & NDR_BUFFERS) {
18072                 switch (level) {
18073                         case 1:
18074                                 if (r->level1) {
18075                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18076                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18077                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18078                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18079                                 }
18080                         break;
18081
18082                         case 2:
18083                                 if (r->level2) {
18084                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18085                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18086                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18087                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18088                                 }
18089                         break;
18090
18091                         case 3:
18092                                 if (r->level3) {
18093                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18094                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18095                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18096                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18097                                 }
18098                         break;
18099
18100                         default:
18101                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18102                 }
18103         }
18104         return NDR_ERR_SUCCESS;
18105 }
18106
18107 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18108 {
18109         int level;
18110         level = ndr_print_get_switch_value(ndr, r);
18111         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18112         switch (level) {
18113                 case 1:
18114                         ndr_print_ptr(ndr, "level1", r->level1);
18115                         ndr->depth++;
18116                         if (r->level1) {
18117                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18118                         }
18119                         ndr->depth--;
18120                 break;
18121
18122                 case 2:
18123                         ndr_print_ptr(ndr, "level2", r->level2);
18124                         ndr->depth++;
18125                         if (r->level2) {
18126                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18127                         }
18128                         ndr->depth--;
18129                 break;
18130
18131                 case 3:
18132                         ndr_print_ptr(ndr, "level3", r->level3);
18133                         ndr->depth++;
18134                         if (r->level3) {
18135                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18136                         }
18137                         ndr->depth--;
18138                 break;
18139
18140                 default:
18141                         ndr_print_bad_level(ndr, name, level);
18142         }
18143 }
18144
18145 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18146 {
18147         if (ndr_flags & NDR_SCALARS) {
18148                 NDR_CHECK(ndr_push_align(ndr, 4));
18149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18150                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18151                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18152         }
18153         if (ndr_flags & NDR_BUFFERS) {
18154                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18155         }
18156         return NDR_ERR_SUCCESS;
18157 }
18158
18159 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18160 {
18161         if (ndr_flags & NDR_SCALARS) {
18162                 NDR_CHECK(ndr_pull_align(ndr, 4));
18163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18164                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18165                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18166         }
18167         if (ndr_flags & NDR_BUFFERS) {
18168                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18169         }
18170         return NDR_ERR_SUCCESS;
18171 }
18172
18173 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18174 {
18175         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18176         ndr->depth++;
18177         ndr_print_uint32(ndr, "level", r->level);
18178         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18179         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18180         ndr->depth--;
18181 }
18182
18183 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18184 {
18185         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18186         return NDR_ERR_SUCCESS;
18187 }
18188
18189 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18190 {
18191         uint32_t v;
18192         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18193         *r = v;
18194         return NDR_ERR_SUCCESS;
18195 }
18196
18197 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18198 {
18199         ndr_print_uint32(ndr, name, r);
18200         ndr->depth++;
18201         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18202         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18203         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18204         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18205         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18206         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18207         ndr->depth--;
18208 }
18209
18210 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18211 {
18212         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18213         return NDR_ERR_SUCCESS;
18214 }
18215
18216 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18217 {
18218         uint32_t v;
18219         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18220         *r = v;
18221         return NDR_ERR_SUCCESS;
18222 }
18223
18224 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18225 {
18226         ndr_print_uint32(ndr, name, r);
18227         ndr->depth++;
18228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18231         ndr->depth--;
18232 }
18233
18234 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18235 {
18236         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18237         return NDR_ERR_SUCCESS;
18238 }
18239
18240 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *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_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18249 {
18250         const char *val = NULL;
18251
18252         switch (r) {
18253                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18254                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18255         }
18256         ndr_print_enum(ndr, name, "ENUM", val, r);
18257 }
18258
18259 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18260 {
18261         if (ndr_flags & NDR_SCALARS) {
18262                 NDR_CHECK(ndr_push_align(ndr, 4));
18263                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18265                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18268                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18269                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18271                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18272                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18273                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18274                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18278         }
18279         if (ndr_flags & NDR_BUFFERS) {
18280         }
18281         return NDR_ERR_SUCCESS;
18282 }
18283
18284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18285 {
18286         if (ndr_flags & NDR_SCALARS) {
18287                 NDR_CHECK(ndr_pull_align(ndr, 4));
18288                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18290                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18293                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18294                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18296                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18297                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18298                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18299                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18303         }
18304         if (ndr_flags & NDR_BUFFERS) {
18305         }
18306         return NDR_ERR_SUCCESS;
18307 }
18308
18309 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18310 {
18311         ndr_print_struct(ndr, name, "spoolss_PortData1");
18312         ndr->depth++;
18313         ndr_print_string(ndr, "portname", r->portname);
18314         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18315         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18316         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18317         ndr_print_uint32(ndr, "reserved", r->reserved);
18318         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18319         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18320         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18321         ndr_print_string(ndr, "queue", r->queue);
18322         ndr_print_string(ndr, "ip_address", r->ip_address);
18323         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18324         ndr_print_string(ndr, "device_type", r->device_type);
18325         ndr_print_uint32(ndr, "port_number", r->port_number);
18326         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18327         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18328         ndr->depth--;
18329 }
18330
18331 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18332 {
18333         if (ndr_flags & NDR_SCALARS) {
18334                 NDR_CHECK(ndr_push_align(ndr, 4));
18335                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18337                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18340                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18341                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18343                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18344                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18349         }
18350         if (ndr_flags & NDR_BUFFERS) {
18351         }
18352         return NDR_ERR_SUCCESS;
18353 }
18354
18355 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18356 {
18357         if (ndr_flags & NDR_SCALARS) {
18358                 NDR_CHECK(ndr_pull_align(ndr, 4));
18359                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18361                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18364                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18365                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18367                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18368                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18372                 NDR_CHECK(ndr_pull_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_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18380 {
18381         ndr_print_struct(ndr, name, "spoolss_PortData2");
18382         ndr->depth++;
18383         ndr_print_string(ndr, "portname", r->portname);
18384         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18385         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18386         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18387         ndr_print_uint32(ndr, "reserved", r->reserved);
18388         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18389         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18390         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18391         ndr_print_string(ndr, "queue", r->queue);
18392         ndr_print_string(ndr, "device_type", r->device_type);
18393         ndr_print_uint32(ndr, "port_number", r->port_number);
18394         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18395         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18396         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18397         ndr->depth--;
18398 }
18399
18400 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18401 {
18402         if (ndr_flags & NDR_SCALARS) {
18403                 NDR_CHECK(ndr_push_align(ndr, 4));
18404                 {
18405                         uint32_t _flags_save_string = ndr->flags;
18406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18407                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18408                         ndr->flags = _flags_save_string;
18409                 }
18410         }
18411         if (ndr_flags & NDR_BUFFERS) {
18412         }
18413         return NDR_ERR_SUCCESS;
18414 }
18415
18416 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18417 {
18418         if (ndr_flags & NDR_SCALARS) {
18419                 NDR_CHECK(ndr_pull_align(ndr, 4));
18420                 {
18421                         uint32_t _flags_save_string = ndr->flags;
18422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18423                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18424                         ndr->flags = _flags_save_string;
18425                 }
18426         }
18427         if (ndr_flags & NDR_BUFFERS) {
18428         }
18429         return NDR_ERR_SUCCESS;
18430 }
18431
18432 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18433 {
18434         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18435         ndr->depth++;
18436         ndr_print_string(ndr, "dll_name", r->dll_name);
18437         ndr->depth--;
18438 }
18439
18440 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18441 {
18442         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18443         return NDR_ERR_SUCCESS;
18444 }
18445
18446 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18447 {
18448         uint32_t v;
18449         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18450         *r = v;
18451         return NDR_ERR_SUCCESS;
18452 }
18453
18454 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18455 {
18456         ndr_print_uint32(ndr, name, r);
18457         ndr->depth++;
18458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18462         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18463         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18464         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18465         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18466         ndr->depth--;
18467 }
18468
18469 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18470 {
18471         if (flags & NDR_IN) {
18472                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18474                 if (r->in.server) {
18475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18479                 }
18480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18482                 if (r->in.buffer) {
18483                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18484                 }
18485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18486         }
18487         if (flags & NDR_OUT) {
18488                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18489                 if (r->out.info) {
18490                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18491                 }
18492                 if (r->out.needed == NULL) {
18493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18494                 }
18495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18496                 if (r->out.count == NULL) {
18497                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18498                 }
18499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18500                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18501         }
18502         return NDR_ERR_SUCCESS;
18503 }
18504
18505 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18506 {
18507         uint32_t _ptr_server;
18508         uint32_t _ptr_buffer;
18509         uint32_t _ptr_info;
18510         TALLOC_CTX *_mem_save_server_0;
18511         TALLOC_CTX *_mem_save_buffer_0;
18512         TALLOC_CTX *_mem_save_info_0;
18513         TALLOC_CTX *_mem_save_needed_0;
18514         TALLOC_CTX *_mem_save_count_0;
18515         if (flags & NDR_IN) {
18516                 ZERO_STRUCT(r->out);
18517
18518                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18520                 if (_ptr_server) {
18521                         NDR_PULL_ALLOC(ndr, r->in.server);
18522                 } else {
18523                         r->in.server = NULL;
18524                 }
18525                 if (r->in.server) {
18526                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18527                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18530                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18531                                 return 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));
18532                         }
18533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18536                 }
18537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18538                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18539                 if (_ptr_buffer) {
18540                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18541                 } else {
18542                         r->in.buffer = NULL;
18543                 }
18544                 if (r->in.buffer) {
18545                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18546                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18547                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18549                 }
18550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18551                 NDR_PULL_ALLOC(ndr, r->out.needed);
18552                 ZERO_STRUCTP(r->out.needed);
18553                 NDR_PULL_ALLOC(ndr, r->out.count);
18554                 ZERO_STRUCTP(r->out.count);
18555         }
18556         if (flags & NDR_OUT) {
18557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18558                 if (_ptr_info) {
18559                         NDR_PULL_ALLOC(ndr, r->out.info);
18560                 } else {
18561                         r->out.info = NULL;
18562                 }
18563                 if (r->out.info) {
18564                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18565                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18566                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18567                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18568                 }
18569                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18570                         NDR_PULL_ALLOC(ndr, r->out.needed);
18571                 }
18572                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18573                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18577                         NDR_PULL_ALLOC(ndr, r->out.count);
18578                 }
18579                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18580                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18584         }
18585         return NDR_ERR_SUCCESS;
18586 }
18587
18588 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18589 {
18590         uint32_t cntr_info_0;
18591         if (flags & NDR_IN) {
18592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18594         }
18595         if (flags & NDR_OUT) {
18596                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18597                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18598                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18599                 }
18600                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18601                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18602                 }
18603         }
18604         return NDR_ERR_SUCCESS;
18605 }
18606
18607 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18608 {
18609         uint32_t cntr_info_0;
18610         TALLOC_CTX *_mem_save_info_0;
18611         if (flags & NDR_IN) {
18612                 ZERO_STRUCT(r->out);
18613
18614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18616         }
18617         if (flags & NDR_OUT) {
18618                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18619                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18621                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18622                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18623                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18624                 }
18625                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18626                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18627                 }
18628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18629         }
18630         return NDR_ERR_SUCCESS;
18631 }
18632
18633 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18634 {
18635         uint32_t cntr_info_2;
18636         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18637         ndr->depth++;
18638         if (flags & NDR_SET_VALUES) {
18639                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18640         }
18641         if (flags & NDR_IN) {
18642                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18643                 ndr->depth++;
18644                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18645                 ndr_print_ptr(ndr, "server", r->in.server);
18646                 ndr->depth++;
18647                 if (r->in.server) {
18648                         ndr_print_string(ndr, "server", r->in.server);
18649                 }
18650                 ndr->depth--;
18651                 ndr_print_uint32(ndr, "level", r->in.level);
18652                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18653                 ndr->depth++;
18654                 if (r->in.buffer) {
18655                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18656                 }
18657                 ndr->depth--;
18658                 ndr_print_uint32(ndr, "offered", r->in.offered);
18659                 ndr->depth--;
18660         }
18661         if (flags & NDR_OUT) {
18662                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18663                 ndr->depth++;
18664                 ndr_print_ptr(ndr, "count", r->out.count);
18665                 ndr->depth++;
18666                 ndr_print_uint32(ndr, "count", *r->out.count);
18667                 ndr->depth--;
18668                 ndr_print_ptr(ndr, "info", r->out.info);
18669                 ndr->depth++;
18670                 ndr_print_ptr(ndr, "info", *r->out.info);
18671                 ndr->depth++;
18672                 if (*r->out.info) {
18673                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18674                         ndr->depth++;
18675                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18676                                 char *idx_2=NULL;
18677                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18678                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18679                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18680                                         free(idx_2);
18681                                 }
18682                         }
18683                         ndr->depth--;
18684                 }
18685                 ndr->depth--;
18686                 ndr->depth--;
18687                 ndr_print_ptr(ndr, "needed", r->out.needed);
18688                 ndr->depth++;
18689                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18690                 ndr->depth--;
18691                 ndr_print_WERROR(ndr, "result", r->out.result);
18692                 ndr->depth--;
18693         }
18694         ndr->depth--;
18695 }
18696
18697 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18698 {
18699         if (flags & NDR_IN) {
18700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18701                 if (r->in.printername) {
18702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18705                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18706                 }
18707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18708                 if (r->in.datatype) {
18709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18713                 }
18714                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18715                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18716         }
18717         if (flags & NDR_OUT) {
18718                 if (r->out.handle == NULL) {
18719                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18720                 }
18721                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18722                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18723         }
18724         return NDR_ERR_SUCCESS;
18725 }
18726
18727 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18728 {
18729         uint32_t _ptr_printername;
18730         uint32_t _ptr_datatype;
18731         TALLOC_CTX *_mem_save_printername_0;
18732         TALLOC_CTX *_mem_save_datatype_0;
18733         TALLOC_CTX *_mem_save_handle_0;
18734         if (flags & NDR_IN) {
18735                 ZERO_STRUCT(r->out);
18736
18737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18738                 if (_ptr_printername) {
18739                         NDR_PULL_ALLOC(ndr, r->in.printername);
18740                 } else {
18741                         r->in.printername = NULL;
18742                 }
18743                 if (r->in.printername) {
18744                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18745                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18746                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18747                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18748                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18749                                 return 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));
18750                         }
18751                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18752                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18754                 }
18755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18756                 if (_ptr_datatype) {
18757                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18758                 } else {
18759                         r->in.datatype = NULL;
18760                 }
18761                 if (r->in.datatype) {
18762                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18763                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18765                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18766                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18767                                 return 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));
18768                         }
18769                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18770                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18772                 }
18773                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18774                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18775                 NDR_PULL_ALLOC(ndr, r->out.handle);
18776                 ZERO_STRUCTP(r->out.handle);
18777         }
18778         if (flags & NDR_OUT) {
18779                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18780                         NDR_PULL_ALLOC(ndr, r->out.handle);
18781                 }
18782                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18783                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18784                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18787         }
18788         return NDR_ERR_SUCCESS;
18789 }
18790
18791 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18792 {
18793         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18794         ndr->depth++;
18795         if (flags & NDR_SET_VALUES) {
18796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18797         }
18798         if (flags & NDR_IN) {
18799                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18800                 ndr->depth++;
18801                 ndr_print_ptr(ndr, "printername", r->in.printername);
18802                 ndr->depth++;
18803                 if (r->in.printername) {
18804                         ndr_print_string(ndr, "printername", r->in.printername);
18805                 }
18806                 ndr->depth--;
18807                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18808                 ndr->depth++;
18809                 if (r->in.datatype) {
18810                         ndr_print_string(ndr, "datatype", r->in.datatype);
18811                 }
18812                 ndr->depth--;
18813                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18814                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18815                 ndr->depth--;
18816         }
18817         if (flags & NDR_OUT) {
18818                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18819                 ndr->depth++;
18820                 ndr_print_ptr(ndr, "handle", r->out.handle);
18821                 ndr->depth++;
18822                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18823                 ndr->depth--;
18824                 ndr_print_WERROR(ndr, "result", r->out.result);
18825                 ndr->depth--;
18826         }
18827         ndr->depth--;
18828 }
18829
18830 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18831 {
18832         if (flags & NDR_IN) {
18833                 if (r->in.handle == NULL) {
18834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18835                 }
18836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18839                 if (r->in.ctr) {
18840                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18841                 }
18842                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18843         }
18844         if (flags & NDR_OUT) {
18845                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18846         }
18847         return NDR_ERR_SUCCESS;
18848 }
18849
18850 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18851 {
18852         uint32_t _ptr_ctr;
18853         TALLOC_CTX *_mem_save_handle_0;
18854         TALLOC_CTX *_mem_save_ctr_0;
18855         if (flags & NDR_IN) {
18856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18857                         NDR_PULL_ALLOC(ndr, r->in.handle);
18858                 }
18859                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18860                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18861                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18865                 if (_ptr_ctr) {
18866                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18867                 } else {
18868                         r->in.ctr = NULL;
18869                 }
18870                 if (r->in.ctr) {
18871                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18872                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18873                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18875                 }
18876                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18877         }
18878         if (flags & NDR_OUT) {
18879                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18880         }
18881         return NDR_ERR_SUCCESS;
18882 }
18883
18884 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18885 {
18886         ndr_print_struct(ndr, name, "spoolss_SetJob");
18887         ndr->depth++;
18888         if (flags & NDR_SET_VALUES) {
18889                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18890         }
18891         if (flags & NDR_IN) {
18892                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18893                 ndr->depth++;
18894                 ndr_print_ptr(ndr, "handle", r->in.handle);
18895                 ndr->depth++;
18896                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18897                 ndr->depth--;
18898                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18899                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18900                 ndr->depth++;
18901                 if (r->in.ctr) {
18902                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18903                 }
18904                 ndr->depth--;
18905                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18906                 ndr->depth--;
18907         }
18908         if (flags & NDR_OUT) {
18909                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18910                 ndr->depth++;
18911                 ndr_print_WERROR(ndr, "result", r->out.result);
18912                 ndr->depth--;
18913         }
18914         ndr->depth--;
18915 }
18916
18917 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18918 {
18919         if (flags & NDR_IN) {
18920                 if (r->in.handle == NULL) {
18921                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18922                 }
18923                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18927                 if (r->in.buffer) {
18928                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18929                 }
18930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18931         }
18932         if (flags & NDR_OUT) {
18933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18934                 if (r->out.info) {
18935                         {
18936                                 struct ndr_push *_ndr_info;
18937                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18938                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18939                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18940                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18941                         }
18942                 }
18943                 if (r->out.needed == NULL) {
18944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18945                 }
18946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18947                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18948         }
18949         return NDR_ERR_SUCCESS;
18950 }
18951
18952 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18953 {
18954         uint32_t _ptr_buffer;
18955         uint32_t _ptr_info;
18956         TALLOC_CTX *_mem_save_handle_0;
18957         TALLOC_CTX *_mem_save_buffer_0;
18958         TALLOC_CTX *_mem_save_info_0;
18959         TALLOC_CTX *_mem_save_needed_0;
18960         if (flags & NDR_IN) {
18961                 ZERO_STRUCT(r->out);
18962
18963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18964                         NDR_PULL_ALLOC(ndr, r->in.handle);
18965                 }
18966                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18967                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18968                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18973                 if (_ptr_buffer) {
18974                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18975                 } else {
18976                         r->in.buffer = NULL;
18977                 }
18978                 if (r->in.buffer) {
18979                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18980                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18981                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18983                 }
18984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18985                 NDR_PULL_ALLOC(ndr, r->out.needed);
18986                 ZERO_STRUCTP(r->out.needed);
18987         }
18988         if (flags & NDR_OUT) {
18989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18990                 if (_ptr_info) {
18991                         NDR_PULL_ALLOC(ndr, r->out.info);
18992                 } else {
18993                         r->out.info = NULL;
18994                 }
18995                 if (r->out.info) {
18996                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18997                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18998                         {
18999                                 struct ndr_pull *_ndr_info;
19000                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19001                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19002                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19003                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19004                         }
19005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19006                 }
19007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19008                         NDR_PULL_ALLOC(ndr, r->out.needed);
19009                 }
19010                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19011                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19015         }
19016         return NDR_ERR_SUCCESS;
19017 }
19018
19019 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19020 {
19021         ndr_print_struct(ndr, name, "spoolss_GetJob");
19022         ndr->depth++;
19023         if (flags & NDR_SET_VALUES) {
19024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19025         }
19026         if (flags & NDR_IN) {
19027                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19028                 ndr->depth++;
19029                 ndr_print_ptr(ndr, "handle", r->in.handle);
19030                 ndr->depth++;
19031                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19032                 ndr->depth--;
19033                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19034                 ndr_print_uint32(ndr, "level", r->in.level);
19035                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19036                 ndr->depth++;
19037                 if (r->in.buffer) {
19038                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19039                 }
19040                 ndr->depth--;
19041                 ndr_print_uint32(ndr, "offered", r->in.offered);
19042                 ndr->depth--;
19043         }
19044         if (flags & NDR_OUT) {
19045                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19046                 ndr->depth++;
19047                 ndr_print_ptr(ndr, "info", r->out.info);
19048                 ndr->depth++;
19049                 if (r->out.info) {
19050                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19051                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19052                 }
19053                 ndr->depth--;
19054                 ndr_print_ptr(ndr, "needed", r->out.needed);
19055                 ndr->depth++;
19056                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19057                 ndr->depth--;
19058                 ndr_print_WERROR(ndr, "result", r->out.result);
19059                 ndr->depth--;
19060         }
19061         ndr->depth--;
19062 }
19063
19064 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19065 {
19066         if (flags & NDR_IN) {
19067                 if (r->in.handle == NULL) {
19068                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19069                 }
19070                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19075                 if (r->in.buffer) {
19076                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19077                 }
19078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19079         }
19080         if (flags & NDR_OUT) {
19081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19082                 if (r->out.info) {
19083                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19084                 }
19085                 if (r->out.needed == NULL) {
19086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19087                 }
19088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19089                 if (r->out.count == NULL) {
19090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19091                 }
19092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19093                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19094         }
19095         return NDR_ERR_SUCCESS;
19096 }
19097
19098 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19099 {
19100         uint32_t _ptr_buffer;
19101         uint32_t _ptr_info;
19102         TALLOC_CTX *_mem_save_handle_0;
19103         TALLOC_CTX *_mem_save_buffer_0;
19104         TALLOC_CTX *_mem_save_info_0;
19105         TALLOC_CTX *_mem_save_needed_0;
19106         TALLOC_CTX *_mem_save_count_0;
19107         if (flags & NDR_IN) {
19108                 ZERO_STRUCT(r->out);
19109
19110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19111                         NDR_PULL_ALLOC(ndr, r->in.handle);
19112                 }
19113                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19114                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19115                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19121                 if (_ptr_buffer) {
19122                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19123                 } else {
19124                         r->in.buffer = NULL;
19125                 }
19126                 if (r->in.buffer) {
19127                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19128                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19129                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19131                 }
19132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19133                 NDR_PULL_ALLOC(ndr, r->out.needed);
19134                 ZERO_STRUCTP(r->out.needed);
19135                 NDR_PULL_ALLOC(ndr, r->out.count);
19136                 ZERO_STRUCTP(r->out.count);
19137         }
19138         if (flags & NDR_OUT) {
19139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19140                 if (_ptr_info) {
19141                         NDR_PULL_ALLOC(ndr, r->out.info);
19142                 } else {
19143                         r->out.info = NULL;
19144                 }
19145                 if (r->out.info) {
19146                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19147                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19148                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19150                 }
19151                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19152                         NDR_PULL_ALLOC(ndr, r->out.needed);
19153                 }
19154                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19155                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19157                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19159                         NDR_PULL_ALLOC(ndr, r->out.count);
19160                 }
19161                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19162                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19165                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19166         }
19167         return NDR_ERR_SUCCESS;
19168 }
19169
19170 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19171 {
19172         uint32_t cntr_info_0;
19173         if (flags & NDR_IN) {
19174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19176         }
19177         if (flags & NDR_OUT) {
19178                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19179                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19180                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19181                 }
19182                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19183                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19184                 }
19185         }
19186         return NDR_ERR_SUCCESS;
19187 }
19188
19189 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19190 {
19191         uint32_t cntr_info_0;
19192         TALLOC_CTX *_mem_save_info_0;
19193         if (flags & NDR_IN) {
19194                 ZERO_STRUCT(r->out);
19195
19196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19198         }
19199         if (flags & NDR_OUT) {
19200                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19201                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19202                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19203                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19204                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19205                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19206                 }
19207                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19208                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19209                 }
19210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19211         }
19212         return NDR_ERR_SUCCESS;
19213 }
19214
19215 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19216 {
19217         uint32_t cntr_info_2;
19218         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19219         ndr->depth++;
19220         if (flags & NDR_SET_VALUES) {
19221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19222         }
19223         if (flags & NDR_IN) {
19224                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19225                 ndr->depth++;
19226                 ndr_print_ptr(ndr, "handle", r->in.handle);
19227                 ndr->depth++;
19228                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19229                 ndr->depth--;
19230                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19231                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19232                 ndr_print_uint32(ndr, "level", r->in.level);
19233                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19234                 ndr->depth++;
19235                 if (r->in.buffer) {
19236                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19237                 }
19238                 ndr->depth--;
19239                 ndr_print_uint32(ndr, "offered", r->in.offered);
19240                 ndr->depth--;
19241         }
19242         if (flags & NDR_OUT) {
19243                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19244                 ndr->depth++;
19245                 ndr_print_ptr(ndr, "count", r->out.count);
19246                 ndr->depth++;
19247                 ndr_print_uint32(ndr, "count", *r->out.count);
19248                 ndr->depth--;
19249                 ndr_print_ptr(ndr, "info", r->out.info);
19250                 ndr->depth++;
19251                 ndr_print_ptr(ndr, "info", *r->out.info);
19252                 ndr->depth++;
19253                 if (*r->out.info) {
19254                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19255                         ndr->depth++;
19256                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19257                                 char *idx_2=NULL;
19258                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19259                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19260                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19261                                         free(idx_2);
19262                                 }
19263                         }
19264                         ndr->depth--;
19265                 }
19266                 ndr->depth--;
19267                 ndr->depth--;
19268                 ndr_print_ptr(ndr, "needed", r->out.needed);
19269                 ndr->depth++;
19270                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19271                 ndr->depth--;
19272                 ndr_print_WERROR(ndr, "result", r->out.result);
19273                 ndr->depth--;
19274         }
19275         ndr->depth--;
19276 }
19277
19278 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19279 {
19280         if (flags & NDR_IN) {
19281         }
19282         if (flags & NDR_OUT) {
19283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19284         }
19285         return NDR_ERR_SUCCESS;
19286 }
19287
19288 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19289 {
19290         if (flags & NDR_IN) {
19291         }
19292         if (flags & NDR_OUT) {
19293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19294         }
19295         return NDR_ERR_SUCCESS;
19296 }
19297
19298 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19299 {
19300         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19301         ndr->depth++;
19302         if (flags & NDR_SET_VALUES) {
19303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19304         }
19305         if (flags & NDR_IN) {
19306                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19307                 ndr->depth++;
19308                 ndr->depth--;
19309         }
19310         if (flags & NDR_OUT) {
19311                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19312                 ndr->depth++;
19313                 ndr_print_WERROR(ndr, "result", r->out.result);
19314                 ndr->depth--;
19315         }
19316         ndr->depth--;
19317 }
19318
19319 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19320 {
19321         if (flags & NDR_IN) {
19322                 if (r->in.handle == NULL) {
19323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19324                 }
19325                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19326         }
19327         if (flags & NDR_OUT) {
19328                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19329         }
19330         return NDR_ERR_SUCCESS;
19331 }
19332
19333 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19334 {
19335         TALLOC_CTX *_mem_save_handle_0;
19336         if (flags & NDR_IN) {
19337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19338                         NDR_PULL_ALLOC(ndr, r->in.handle);
19339                 }
19340                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19341                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19342                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19344         }
19345         if (flags & NDR_OUT) {
19346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19347         }
19348         return NDR_ERR_SUCCESS;
19349 }
19350
19351 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19352 {
19353         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19354         ndr->depth++;
19355         if (flags & NDR_SET_VALUES) {
19356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19357         }
19358         if (flags & NDR_IN) {
19359                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19360                 ndr->depth++;
19361                 ndr_print_ptr(ndr, "handle", r->in.handle);
19362                 ndr->depth++;
19363                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19364                 ndr->depth--;
19365                 ndr->depth--;
19366         }
19367         if (flags & NDR_OUT) {
19368                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19369                 ndr->depth++;
19370                 ndr_print_WERROR(ndr, "result", r->out.result);
19371                 ndr->depth--;
19372         }
19373         ndr->depth--;
19374 }
19375
19376 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19377 {
19378         if (flags & NDR_IN) {
19379                 if (r->in.handle == NULL) {
19380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19381                 }
19382                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19383                 if (r->in.info_ctr == NULL) {
19384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19385                 }
19386                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19387                 if (r->in.devmode_ctr == NULL) {
19388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19389                 }
19390                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19391                 if (r->in.secdesc_ctr == NULL) {
19392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19393                 }
19394                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19395                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19396         }
19397         if (flags & NDR_OUT) {
19398                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19399         }
19400         return NDR_ERR_SUCCESS;
19401 }
19402
19403 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19404 {
19405         TALLOC_CTX *_mem_save_handle_0;
19406         TALLOC_CTX *_mem_save_info_ctr_0;
19407         TALLOC_CTX *_mem_save_devmode_ctr_0;
19408         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19409         if (flags & NDR_IN) {
19410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19411                         NDR_PULL_ALLOC(ndr, r->in.handle);
19412                 }
19413                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19414                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19415                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19418                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19419                 }
19420                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19421                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19422                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19425                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19426                 }
19427                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19428                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19429                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19432                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19433                 }
19434                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19435                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19436                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19438                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19439         }
19440         if (flags & NDR_OUT) {
19441                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19442         }
19443         return NDR_ERR_SUCCESS;
19444 }
19445
19446 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19447 {
19448         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19449         ndr->depth++;
19450         if (flags & NDR_SET_VALUES) {
19451                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19452         }
19453         if (flags & NDR_IN) {
19454                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19455                 ndr->depth++;
19456                 ndr_print_ptr(ndr, "handle", r->in.handle);
19457                 ndr->depth++;
19458                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19459                 ndr->depth--;
19460                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19461                 ndr->depth++;
19462                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19463                 ndr->depth--;
19464                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19465                 ndr->depth++;
19466                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19467                 ndr->depth--;
19468                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19469                 ndr->depth++;
19470                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19471                 ndr->depth--;
19472                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19473                 ndr->depth--;
19474         }
19475         if (flags & NDR_OUT) {
19476                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19477                 ndr->depth++;
19478                 ndr_print_WERROR(ndr, "result", r->out.result);
19479                 ndr->depth--;
19480         }
19481         ndr->depth--;
19482 }
19483
19484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19485 {
19486         if (flags & NDR_IN) {
19487                 if (r->in.handle == NULL) {
19488                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19489                 }
19490                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19493                 if (r->in.buffer) {
19494                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19495                 }
19496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19497         }
19498         if (flags & NDR_OUT) {
19499                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19500                 if (r->out.info) {
19501                         {
19502                                 struct ndr_push *_ndr_info;
19503                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19504                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19505                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19506                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19507                         }
19508                 }
19509                 if (r->out.needed == NULL) {
19510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19511                 }
19512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19513                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19514         }
19515         return NDR_ERR_SUCCESS;
19516 }
19517
19518 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19519 {
19520         uint32_t _ptr_buffer;
19521         uint32_t _ptr_info;
19522         TALLOC_CTX *_mem_save_handle_0;
19523         TALLOC_CTX *_mem_save_buffer_0;
19524         TALLOC_CTX *_mem_save_info_0;
19525         TALLOC_CTX *_mem_save_needed_0;
19526         if (flags & NDR_IN) {
19527                 ZERO_STRUCT(r->out);
19528
19529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19530                         NDR_PULL_ALLOC(ndr, r->in.handle);
19531                 }
19532                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19533                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19534                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19538                 if (_ptr_buffer) {
19539                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19540                 } else {
19541                         r->in.buffer = NULL;
19542                 }
19543                 if (r->in.buffer) {
19544                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19545                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19546                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19548                 }
19549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19550                 NDR_PULL_ALLOC(ndr, r->out.needed);
19551                 ZERO_STRUCTP(r->out.needed);
19552         }
19553         if (flags & NDR_OUT) {
19554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19555                 if (_ptr_info) {
19556                         NDR_PULL_ALLOC(ndr, r->out.info);
19557                 } else {
19558                         r->out.info = NULL;
19559                 }
19560                 if (r->out.info) {
19561                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19562                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19563                         {
19564                                 struct ndr_pull *_ndr_info;
19565                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19566                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19567                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19568                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19569                         }
19570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19571                 }
19572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19573                         NDR_PULL_ALLOC(ndr, r->out.needed);
19574                 }
19575                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19580         }
19581         return NDR_ERR_SUCCESS;
19582 }
19583
19584 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19585 {
19586         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19587         ndr->depth++;
19588         if (flags & NDR_SET_VALUES) {
19589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19590         }
19591         if (flags & NDR_IN) {
19592                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19593                 ndr->depth++;
19594                 ndr_print_ptr(ndr, "handle", r->in.handle);
19595                 ndr->depth++;
19596                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19597                 ndr->depth--;
19598                 ndr_print_uint32(ndr, "level", r->in.level);
19599                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19600                 ndr->depth++;
19601                 if (r->in.buffer) {
19602                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19603                 }
19604                 ndr->depth--;
19605                 ndr_print_uint32(ndr, "offered", r->in.offered);
19606                 ndr->depth--;
19607         }
19608         if (flags & NDR_OUT) {
19609                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19610                 ndr->depth++;
19611                 ndr_print_ptr(ndr, "info", r->out.info);
19612                 ndr->depth++;
19613                 if (r->out.info) {
19614                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19615                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19616                 }
19617                 ndr->depth--;
19618                 ndr_print_ptr(ndr, "needed", r->out.needed);
19619                 ndr->depth++;
19620                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19621                 ndr->depth--;
19622                 ndr_print_WERROR(ndr, "result", r->out.result);
19623                 ndr->depth--;
19624         }
19625         ndr->depth--;
19626 }
19627
19628 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19629 {
19630         if (flags & NDR_IN) {
19631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19632                 if (r->in.servername) {
19633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19635                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19636                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19637                 }
19638                 if (r->in.info_ctr == NULL) {
19639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19640                 }
19641                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19642         }
19643         if (flags & NDR_OUT) {
19644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19645         }
19646         return NDR_ERR_SUCCESS;
19647 }
19648
19649 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19650 {
19651         uint32_t _ptr_servername;
19652         TALLOC_CTX *_mem_save_servername_0;
19653         TALLOC_CTX *_mem_save_info_ctr_0;
19654         if (flags & NDR_IN) {
19655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19656                 if (_ptr_servername) {
19657                         NDR_PULL_ALLOC(ndr, r->in.servername);
19658                 } else {
19659                         r->in.servername = NULL;
19660                 }
19661                 if (r->in.servername) {
19662                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19663                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19666                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19667                                 return 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));
19668                         }
19669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19672                 }
19673                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19674                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19675                 }
19676                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19677                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19678                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19679                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19680         }
19681         if (flags & NDR_OUT) {
19682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19683         }
19684         return NDR_ERR_SUCCESS;
19685 }
19686
19687 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19688 {
19689         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19690         ndr->depth++;
19691         if (flags & NDR_SET_VALUES) {
19692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19693         }
19694         if (flags & NDR_IN) {
19695                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19696                 ndr->depth++;
19697                 ndr_print_ptr(ndr, "servername", r->in.servername);
19698                 ndr->depth++;
19699                 if (r->in.servername) {
19700                         ndr_print_string(ndr, "servername", r->in.servername);
19701                 }
19702                 ndr->depth--;
19703                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19704                 ndr->depth++;
19705                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19706                 ndr->depth--;
19707                 ndr->depth--;
19708         }
19709         if (flags & NDR_OUT) {
19710                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19711                 ndr->depth++;
19712                 ndr_print_WERROR(ndr, "result", r->out.result);
19713                 ndr->depth--;
19714         }
19715         ndr->depth--;
19716 }
19717
19718 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19719 {
19720         if (flags & NDR_IN) {
19721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19722                 if (r->in.server) {
19723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19727                 }
19728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19729                 if (r->in.environment) {
19730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19734                 }
19735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19737                 if (r->in.buffer) {
19738                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19739                 }
19740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19741         }
19742         if (flags & NDR_OUT) {
19743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19744                 if (r->out.info) {
19745                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19746                 }
19747                 if (r->out.needed == NULL) {
19748                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19749                 }
19750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19751                 if (r->out.count == NULL) {
19752                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19753                 }
19754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19755                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19756         }
19757         return NDR_ERR_SUCCESS;
19758 }
19759
19760 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19761 {
19762         uint32_t _ptr_server;
19763         uint32_t _ptr_environment;
19764         uint32_t _ptr_buffer;
19765         uint32_t _ptr_info;
19766         TALLOC_CTX *_mem_save_server_0;
19767         TALLOC_CTX *_mem_save_environment_0;
19768         TALLOC_CTX *_mem_save_buffer_0;
19769         TALLOC_CTX *_mem_save_info_0;
19770         TALLOC_CTX *_mem_save_needed_0;
19771         TALLOC_CTX *_mem_save_count_0;
19772         if (flags & NDR_IN) {
19773                 ZERO_STRUCT(r->out);
19774
19775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19776                 if (_ptr_server) {
19777                         NDR_PULL_ALLOC(ndr, r->in.server);
19778                 } else {
19779                         r->in.server = NULL;
19780                 }
19781                 if (r->in.server) {
19782                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19783                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19786                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19787                                 return 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));
19788                         }
19789                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19790                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19792                 }
19793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19794                 if (_ptr_environment) {
19795                         NDR_PULL_ALLOC(ndr, r->in.environment);
19796                 } else {
19797                         r->in.environment = NULL;
19798                 }
19799                 if (r->in.environment) {
19800                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19801                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19804                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19805                                 return 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));
19806                         }
19807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19810                 }
19811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19813                 if (_ptr_buffer) {
19814                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19815                 } else {
19816                         r->in.buffer = NULL;
19817                 }
19818                 if (r->in.buffer) {
19819                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19820                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19821                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19823                 }
19824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19825                 NDR_PULL_ALLOC(ndr, r->out.needed);
19826                 ZERO_STRUCTP(r->out.needed);
19827                 NDR_PULL_ALLOC(ndr, r->out.count);
19828                 ZERO_STRUCTP(r->out.count);
19829         }
19830         if (flags & NDR_OUT) {
19831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19832                 if (_ptr_info) {
19833                         NDR_PULL_ALLOC(ndr, r->out.info);
19834                 } else {
19835                         r->out.info = NULL;
19836                 }
19837                 if (r->out.info) {
19838                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19839                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19840                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19841                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19842                 }
19843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19844                         NDR_PULL_ALLOC(ndr, r->out.needed);
19845                 }
19846                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19851                         NDR_PULL_ALLOC(ndr, r->out.count);
19852                 }
19853                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19854                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19857                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19858         }
19859         return NDR_ERR_SUCCESS;
19860 }
19861
19862 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19863 {
19864         uint32_t cntr_info_0;
19865         if (flags & NDR_IN) {
19866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19868         }
19869         if (flags & NDR_OUT) {
19870                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19871                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19872                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19873                 }
19874                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19875                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19876                 }
19877         }
19878         return NDR_ERR_SUCCESS;
19879 }
19880
19881 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19882 {
19883         uint32_t cntr_info_0;
19884         TALLOC_CTX *_mem_save_info_0;
19885         if (flags & NDR_IN) {
19886                 ZERO_STRUCT(r->out);
19887
19888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19890         }
19891         if (flags & NDR_OUT) {
19892                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19893                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19894                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19895                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19896                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19897                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19898                 }
19899                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19900                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19901                 }
19902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19903         }
19904         return NDR_ERR_SUCCESS;
19905 }
19906
19907 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19908 {
19909         uint32_t cntr_info_2;
19910         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19911         ndr->depth++;
19912         if (flags & NDR_SET_VALUES) {
19913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19914         }
19915         if (flags & NDR_IN) {
19916                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19917                 ndr->depth++;
19918                 ndr_print_ptr(ndr, "server", r->in.server);
19919                 ndr->depth++;
19920                 if (r->in.server) {
19921                         ndr_print_string(ndr, "server", r->in.server);
19922                 }
19923                 ndr->depth--;
19924                 ndr_print_ptr(ndr, "environment", r->in.environment);
19925                 ndr->depth++;
19926                 if (r->in.environment) {
19927                         ndr_print_string(ndr, "environment", r->in.environment);
19928                 }
19929                 ndr->depth--;
19930                 ndr_print_uint32(ndr, "level", r->in.level);
19931                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19932                 ndr->depth++;
19933                 if (r->in.buffer) {
19934                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19935                 }
19936                 ndr->depth--;
19937                 ndr_print_uint32(ndr, "offered", r->in.offered);
19938                 ndr->depth--;
19939         }
19940         if (flags & NDR_OUT) {
19941                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19942                 ndr->depth++;
19943                 ndr_print_ptr(ndr, "count", r->out.count);
19944                 ndr->depth++;
19945                 ndr_print_uint32(ndr, "count", *r->out.count);
19946                 ndr->depth--;
19947                 ndr_print_ptr(ndr, "info", r->out.info);
19948                 ndr->depth++;
19949                 ndr_print_ptr(ndr, "info", *r->out.info);
19950                 ndr->depth++;
19951                 if (*r->out.info) {
19952                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19953                         ndr->depth++;
19954                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19955                                 char *idx_2=NULL;
19956                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19957                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19958                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19959                                         free(idx_2);
19960                                 }
19961                         }
19962                         ndr->depth--;
19963                 }
19964                 ndr->depth--;
19965                 ndr->depth--;
19966                 ndr_print_ptr(ndr, "needed", r->out.needed);
19967                 ndr->depth++;
19968                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19969                 ndr->depth--;
19970                 ndr_print_WERROR(ndr, "result", r->out.result);
19971                 ndr->depth--;
19972         }
19973         ndr->depth--;
19974 }
19975
19976 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
19977 {
19978         if (flags & NDR_IN) {
19979         }
19980         if (flags & NDR_OUT) {
19981                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19982         }
19983         return NDR_ERR_SUCCESS;
19984 }
19985
19986 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
19987 {
19988         if (flags & NDR_IN) {
19989         }
19990         if (flags & NDR_OUT) {
19991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19992         }
19993         return NDR_ERR_SUCCESS;
19994 }
19995
19996 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
19997 {
19998         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
19999         ndr->depth++;
20000         if (flags & NDR_SET_VALUES) {
20001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20002         }
20003         if (flags & NDR_IN) {
20004                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20005                 ndr->depth++;
20006                 ndr->depth--;
20007         }
20008         if (flags & NDR_OUT) {
20009                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20010                 ndr->depth++;
20011                 ndr_print_WERROR(ndr, "result", r->out.result);
20012                 ndr->depth--;
20013         }
20014         ndr->depth--;
20015 }
20016
20017 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20018 {
20019         if (flags & NDR_IN) {
20020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20021                 if (r->in.server) {
20022                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20025                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20026                 }
20027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20028                 if (r->in.environment) {
20029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20033                 }
20034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20036                 if (r->in.buffer) {
20037                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20038                 }
20039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20040         }
20041         if (flags & NDR_OUT) {
20042                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20043                 if (r->out.info) {
20044                         {
20045                                 struct ndr_push *_ndr_info;
20046                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20047                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20048                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20049                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20050                         }
20051                 }
20052                 if (r->out.needed == NULL) {
20053                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20054                 }
20055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20056                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20057         }
20058         return NDR_ERR_SUCCESS;
20059 }
20060
20061 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20062 {
20063         uint32_t _ptr_server;
20064         uint32_t _ptr_environment;
20065         uint32_t _ptr_buffer;
20066         uint32_t _ptr_info;
20067         TALLOC_CTX *_mem_save_server_0;
20068         TALLOC_CTX *_mem_save_environment_0;
20069         TALLOC_CTX *_mem_save_buffer_0;
20070         TALLOC_CTX *_mem_save_info_0;
20071         TALLOC_CTX *_mem_save_needed_0;
20072         if (flags & NDR_IN) {
20073                 ZERO_STRUCT(r->out);
20074
20075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20076                 if (_ptr_server) {
20077                         NDR_PULL_ALLOC(ndr, r->in.server);
20078                 } else {
20079                         r->in.server = NULL;
20080                 }
20081                 if (r->in.server) {
20082                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20083                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20086                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20087                                 return 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));
20088                         }
20089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20092                 }
20093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20094                 if (_ptr_environment) {
20095                         NDR_PULL_ALLOC(ndr, r->in.environment);
20096                 } else {
20097                         r->in.environment = NULL;
20098                 }
20099                 if (r->in.environment) {
20100                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20101                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20104                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20105                                 return 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));
20106                         }
20107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20110                 }
20111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20113                 if (_ptr_buffer) {
20114                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20115                 } else {
20116                         r->in.buffer = NULL;
20117                 }
20118                 if (r->in.buffer) {
20119                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20120                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20121                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20123                 }
20124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20125                 NDR_PULL_ALLOC(ndr, r->out.needed);
20126                 ZERO_STRUCTP(r->out.needed);
20127         }
20128         if (flags & NDR_OUT) {
20129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20130                 if (_ptr_info) {
20131                         NDR_PULL_ALLOC(ndr, r->out.info);
20132                 } else {
20133                         r->out.info = NULL;
20134                 }
20135                 if (r->out.info) {
20136                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20137                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20138                         {
20139                                 struct ndr_pull *_ndr_info;
20140                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20141                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20142                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20143                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20144                         }
20145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20146                 }
20147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20148                         NDR_PULL_ALLOC(ndr, r->out.needed);
20149                 }
20150                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20151                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20155         }
20156         return NDR_ERR_SUCCESS;
20157 }
20158
20159 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20160 {
20161         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20162         ndr->depth++;
20163         if (flags & NDR_SET_VALUES) {
20164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20165         }
20166         if (flags & NDR_IN) {
20167                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20168                 ndr->depth++;
20169                 ndr_print_ptr(ndr, "server", r->in.server);
20170                 ndr->depth++;
20171                 if (r->in.server) {
20172                         ndr_print_string(ndr, "server", r->in.server);
20173                 }
20174                 ndr->depth--;
20175                 ndr_print_ptr(ndr, "environment", r->in.environment);
20176                 ndr->depth++;
20177                 if (r->in.environment) {
20178                         ndr_print_string(ndr, "environment", r->in.environment);
20179                 }
20180                 ndr->depth--;
20181                 ndr_print_uint32(ndr, "level", r->in.level);
20182                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20183                 ndr->depth++;
20184                 if (r->in.buffer) {
20185                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20186                 }
20187                 ndr->depth--;
20188                 ndr_print_uint32(ndr, "offered", r->in.offered);
20189                 ndr->depth--;
20190         }
20191         if (flags & NDR_OUT) {
20192                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20193                 ndr->depth++;
20194                 ndr_print_ptr(ndr, "info", r->out.info);
20195                 ndr->depth++;
20196                 if (r->out.info) {
20197                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20198                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20199                 }
20200                 ndr->depth--;
20201                 ndr_print_ptr(ndr, "needed", r->out.needed);
20202                 ndr->depth++;
20203                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20204                 ndr->depth--;
20205                 ndr_print_WERROR(ndr, "result", r->out.result);
20206                 ndr->depth--;
20207         }
20208         ndr->depth--;
20209 }
20210
20211 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20212 {
20213         if (flags & NDR_IN) {
20214                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20215                 if (r->in.server) {
20216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20219                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20220                 }
20221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20224                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20228                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20229         }
20230         if (flags & NDR_OUT) {
20231                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20232         }
20233         return NDR_ERR_SUCCESS;
20234 }
20235
20236 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20237 {
20238         uint32_t _ptr_server;
20239         TALLOC_CTX *_mem_save_server_0;
20240         if (flags & NDR_IN) {
20241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20242                 if (_ptr_server) {
20243                         NDR_PULL_ALLOC(ndr, r->in.server);
20244                 } else {
20245                         r->in.server = NULL;
20246                 }
20247                 if (r->in.server) {
20248                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20252                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20253                                 return 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));
20254                         }
20255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20258                 }
20259                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20260                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20261                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20262                         return 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));
20263                 }
20264                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20265                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20266                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20267                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20268                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20269                         return 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));
20270                 }
20271                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20272                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20273         }
20274         if (flags & NDR_OUT) {
20275                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20276         }
20277         return NDR_ERR_SUCCESS;
20278 }
20279
20280 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20281 {
20282         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20283         ndr->depth++;
20284         if (flags & NDR_SET_VALUES) {
20285                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20286         }
20287         if (flags & NDR_IN) {
20288                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20289                 ndr->depth++;
20290                 ndr_print_ptr(ndr, "server", r->in.server);
20291                 ndr->depth++;
20292                 if (r->in.server) {
20293                         ndr_print_string(ndr, "server", r->in.server);
20294                 }
20295                 ndr->depth--;
20296                 ndr_print_string(ndr, "architecture", r->in.architecture);
20297                 ndr_print_string(ndr, "driver", r->in.driver);
20298                 ndr->depth--;
20299         }
20300         if (flags & NDR_OUT) {
20301                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20302                 ndr->depth++;
20303                 ndr_print_WERROR(ndr, "result", r->out.result);
20304                 ndr->depth--;
20305         }
20306         ndr->depth--;
20307 }
20308
20309 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20310 {
20311         if (flags & NDR_IN) {
20312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20313                 if (r->in.server) {
20314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20315                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20316                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20317                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20318                 }
20319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20322                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20326                 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));
20327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20330                 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));
20331         }
20332         if (flags & NDR_OUT) {
20333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20334         }
20335         return NDR_ERR_SUCCESS;
20336 }
20337
20338 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20339 {
20340         uint32_t _ptr_server;
20341         TALLOC_CTX *_mem_save_server_0;
20342         if (flags & NDR_IN) {
20343                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20344                 if (_ptr_server) {
20345                         NDR_PULL_ALLOC(ndr, r->in.server);
20346                 } else {
20347                         r->in.server = NULL;
20348                 }
20349                 if (r->in.server) {
20350                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20351                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20354                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20355                                 return 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));
20356                         }
20357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20358                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20360                 }
20361                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20362                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20363                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20364                         return 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));
20365                 }
20366                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20367                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20368                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20369                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20370                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20371                         return 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));
20372                 }
20373                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20374                 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));
20375                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20376                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20377                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20378                         return 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));
20379                 }
20380                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20381                 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));
20382         }
20383         if (flags & NDR_OUT) {
20384                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20385         }
20386         return NDR_ERR_SUCCESS;
20387 }
20388
20389 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20390 {
20391         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20392         ndr->depth++;
20393         if (flags & NDR_SET_VALUES) {
20394                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20395         }
20396         if (flags & NDR_IN) {
20397                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20398                 ndr->depth++;
20399                 ndr_print_ptr(ndr, "server", r->in.server);
20400                 ndr->depth++;
20401                 if (r->in.server) {
20402                         ndr_print_string(ndr, "server", r->in.server);
20403                 }
20404                 ndr->depth--;
20405                 ndr_print_string(ndr, "architecture", r->in.architecture);
20406                 ndr_print_string(ndr, "path_name", r->in.path_name);
20407                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20408                 ndr->depth--;
20409         }
20410         if (flags & NDR_OUT) {
20411                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20412                 ndr->depth++;
20413                 ndr_print_WERROR(ndr, "result", r->out.result);
20414                 ndr->depth--;
20415         }
20416         ndr->depth--;
20417 }
20418
20419 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20420 {
20421         if (flags & NDR_IN) {
20422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20423                 if (r->in.servername) {
20424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20428                 }
20429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20430                 if (r->in.environment) {
20431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20435                 }
20436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20438                 if (r->in.buffer) {
20439                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20440                 }
20441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20442         }
20443         if (flags & NDR_OUT) {
20444                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20445                 if (r->out.info) {
20446                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20447                 }
20448                 if (r->out.needed == NULL) {
20449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20450                 }
20451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20452                 if (r->out.count == NULL) {
20453                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20454                 }
20455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20457         }
20458         return NDR_ERR_SUCCESS;
20459 }
20460
20461 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20462 {
20463         uint32_t _ptr_servername;
20464         uint32_t _ptr_environment;
20465         uint32_t _ptr_buffer;
20466         uint32_t _ptr_info;
20467         TALLOC_CTX *_mem_save_servername_0;
20468         TALLOC_CTX *_mem_save_environment_0;
20469         TALLOC_CTX *_mem_save_buffer_0;
20470         TALLOC_CTX *_mem_save_info_0;
20471         TALLOC_CTX *_mem_save_needed_0;
20472         TALLOC_CTX *_mem_save_count_0;
20473         if (flags & NDR_IN) {
20474                 ZERO_STRUCT(r->out);
20475
20476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20477                 if (_ptr_servername) {
20478                         NDR_PULL_ALLOC(ndr, r->in.servername);
20479                 } else {
20480                         r->in.servername = NULL;
20481                 }
20482                 if (r->in.servername) {
20483                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20484                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20487                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20488                                 return 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));
20489                         }
20490                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20493                 }
20494                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20495                 if (_ptr_environment) {
20496                         NDR_PULL_ALLOC(ndr, r->in.environment);
20497                 } else {
20498                         r->in.environment = NULL;
20499                 }
20500                 if (r->in.environment) {
20501                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20502                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20503                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20504                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20505                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20506                                 return 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));
20507                         }
20508                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20509                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20511                 }
20512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20513                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20514                 if (_ptr_buffer) {
20515                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20516                 } else {
20517                         r->in.buffer = NULL;
20518                 }
20519                 if (r->in.buffer) {
20520                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20521                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20522                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20524                 }
20525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20526                 NDR_PULL_ALLOC(ndr, r->out.needed);
20527                 ZERO_STRUCTP(r->out.needed);
20528                 NDR_PULL_ALLOC(ndr, r->out.count);
20529                 ZERO_STRUCTP(r->out.count);
20530         }
20531         if (flags & NDR_OUT) {
20532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20533                 if (_ptr_info) {
20534                         NDR_PULL_ALLOC(ndr, r->out.info);
20535                 } else {
20536                         r->out.info = NULL;
20537                 }
20538                 if (r->out.info) {
20539                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20540                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20541                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20543                 }
20544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20545                         NDR_PULL_ALLOC(ndr, r->out.needed);
20546                 }
20547                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20552                         NDR_PULL_ALLOC(ndr, r->out.count);
20553                 }
20554                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20555                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20558                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20559         }
20560         return NDR_ERR_SUCCESS;
20561 }
20562
20563 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20564 {
20565         uint32_t cntr_info_0;
20566         if (flags & NDR_IN) {
20567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20569         }
20570         if (flags & NDR_OUT) {
20571                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20572                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20573                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20574                 }
20575                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20576                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20577                 }
20578         }
20579         return NDR_ERR_SUCCESS;
20580 }
20581
20582 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20583 {
20584         uint32_t cntr_info_0;
20585         TALLOC_CTX *_mem_save_info_0;
20586         if (flags & NDR_IN) {
20587                 ZERO_STRUCT(r->out);
20588
20589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20591         }
20592         if (flags & NDR_OUT) {
20593                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20594                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20595                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20596                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20597                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20598                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20599                 }
20600                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20601                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20602                 }
20603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20604         }
20605         return NDR_ERR_SUCCESS;
20606 }
20607
20608 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20609 {
20610         uint32_t cntr_info_2;
20611         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20612         ndr->depth++;
20613         if (flags & NDR_SET_VALUES) {
20614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20615         }
20616         if (flags & NDR_IN) {
20617                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20618                 ndr->depth++;
20619                 ndr_print_ptr(ndr, "servername", r->in.servername);
20620                 ndr->depth++;
20621                 if (r->in.servername) {
20622                         ndr_print_string(ndr, "servername", r->in.servername);
20623                 }
20624                 ndr->depth--;
20625                 ndr_print_ptr(ndr, "environment", r->in.environment);
20626                 ndr->depth++;
20627                 if (r->in.environment) {
20628                         ndr_print_string(ndr, "environment", r->in.environment);
20629                 }
20630                 ndr->depth--;
20631                 ndr_print_uint32(ndr, "level", r->in.level);
20632                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20633                 ndr->depth++;
20634                 if (r->in.buffer) {
20635                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20636                 }
20637                 ndr->depth--;
20638                 ndr_print_uint32(ndr, "offered", r->in.offered);
20639                 ndr->depth--;
20640         }
20641         if (flags & NDR_OUT) {
20642                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20643                 ndr->depth++;
20644                 ndr_print_ptr(ndr, "count", r->out.count);
20645                 ndr->depth++;
20646                 ndr_print_uint32(ndr, "count", *r->out.count);
20647                 ndr->depth--;
20648                 ndr_print_ptr(ndr, "info", r->out.info);
20649                 ndr->depth++;
20650                 ndr_print_ptr(ndr, "info", *r->out.info);
20651                 ndr->depth++;
20652                 if (*r->out.info) {
20653                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20654                         ndr->depth++;
20655                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20656                                 char *idx_2=NULL;
20657                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20658                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20659                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20660                                         free(idx_2);
20661                                 }
20662                         }
20663                         ndr->depth--;
20664                 }
20665                 ndr->depth--;
20666                 ndr->depth--;
20667                 ndr_print_ptr(ndr, "needed", r->out.needed);
20668                 ndr->depth++;
20669                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20670                 ndr->depth--;
20671                 ndr_print_WERROR(ndr, "result", r->out.result);
20672                 ndr->depth--;
20673         }
20674         ndr->depth--;
20675 }
20676
20677 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20678 {
20679         if (flags & NDR_IN) {
20680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20681                 if (r->in.server) {
20682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20685                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20686                 }
20687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20688                 if (r->in.environment) {
20689                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20690                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20692                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20693                 }
20694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20696                 if (r->in.buffer) {
20697                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20698                 }
20699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20700         }
20701         if (flags & NDR_OUT) {
20702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20703                 if (r->out.info) {
20704                         {
20705                                 struct ndr_push *_ndr_info;
20706                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20707                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20708                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20709                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20710                         }
20711                 }
20712                 if (r->out.needed == NULL) {
20713                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20714                 }
20715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20716                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20717         }
20718         return NDR_ERR_SUCCESS;
20719 }
20720
20721 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20722 {
20723         uint32_t _ptr_server;
20724         uint32_t _ptr_environment;
20725         uint32_t _ptr_buffer;
20726         uint32_t _ptr_info;
20727         TALLOC_CTX *_mem_save_server_0;
20728         TALLOC_CTX *_mem_save_environment_0;
20729         TALLOC_CTX *_mem_save_buffer_0;
20730         TALLOC_CTX *_mem_save_info_0;
20731         TALLOC_CTX *_mem_save_needed_0;
20732         if (flags & NDR_IN) {
20733                 ZERO_STRUCT(r->out);
20734
20735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20736                 if (_ptr_server) {
20737                         NDR_PULL_ALLOC(ndr, r->in.server);
20738                 } else {
20739                         r->in.server = NULL;
20740                 }
20741                 if (r->in.server) {
20742                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20743                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20744                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20745                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20746                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20747                                 return 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));
20748                         }
20749                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20750                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20751                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20752                 }
20753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20754                 if (_ptr_environment) {
20755                         NDR_PULL_ALLOC(ndr, r->in.environment);
20756                 } else {
20757                         r->in.environment = NULL;
20758                 }
20759                 if (r->in.environment) {
20760                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20761                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20764                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20765                                 return 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));
20766                         }
20767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20770                 }
20771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20773                 if (_ptr_buffer) {
20774                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20775                 } else {
20776                         r->in.buffer = NULL;
20777                 }
20778                 if (r->in.buffer) {
20779                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20780                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20781                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20783                 }
20784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20785                 NDR_PULL_ALLOC(ndr, r->out.needed);
20786                 ZERO_STRUCTP(r->out.needed);
20787         }
20788         if (flags & NDR_OUT) {
20789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20790                 if (_ptr_info) {
20791                         NDR_PULL_ALLOC(ndr, r->out.info);
20792                 } else {
20793                         r->out.info = NULL;
20794                 }
20795                 if (r->out.info) {
20796                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20797                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20798                         {
20799                                 struct ndr_pull *_ndr_info;
20800                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20801                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20802                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20803                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20804                         }
20805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20806                 }
20807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20808                         NDR_PULL_ALLOC(ndr, r->out.needed);
20809                 }
20810                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20811                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20815         }
20816         return NDR_ERR_SUCCESS;
20817 }
20818
20819 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20820 {
20821         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20822         ndr->depth++;
20823         if (flags & NDR_SET_VALUES) {
20824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20825         }
20826         if (flags & NDR_IN) {
20827                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20828                 ndr->depth++;
20829                 ndr_print_ptr(ndr, "server", r->in.server);
20830                 ndr->depth++;
20831                 if (r->in.server) {
20832                         ndr_print_string(ndr, "server", r->in.server);
20833                 }
20834                 ndr->depth--;
20835                 ndr_print_ptr(ndr, "environment", r->in.environment);
20836                 ndr->depth++;
20837                 if (r->in.environment) {
20838                         ndr_print_string(ndr, "environment", r->in.environment);
20839                 }
20840                 ndr->depth--;
20841                 ndr_print_uint32(ndr, "level", r->in.level);
20842                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20843                 ndr->depth++;
20844                 if (r->in.buffer) {
20845                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20846                 }
20847                 ndr->depth--;
20848                 ndr_print_uint32(ndr, "offered", r->in.offered);
20849                 ndr->depth--;
20850         }
20851         if (flags & NDR_OUT) {
20852                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20853                 ndr->depth++;
20854                 ndr_print_ptr(ndr, "info", r->out.info);
20855                 ndr->depth++;
20856                 if (r->out.info) {
20857                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20858                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20859                 }
20860                 ndr->depth--;
20861                 ndr_print_ptr(ndr, "needed", r->out.needed);
20862                 ndr->depth++;
20863                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20864                 ndr->depth--;
20865                 ndr_print_WERROR(ndr, "result", r->out.result);
20866                 ndr->depth--;
20867         }
20868         ndr->depth--;
20869 }
20870
20871 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20872 {
20873         if (flags & NDR_IN) {
20874                 if (r->in.handle == NULL) {
20875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20876                 }
20877                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20879                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20880                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20881         }
20882         if (flags & NDR_OUT) {
20883                 if (r->out.job_id == NULL) {
20884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20885                 }
20886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20888         }
20889         return NDR_ERR_SUCCESS;
20890 }
20891
20892 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20893 {
20894         TALLOC_CTX *_mem_save_handle_0;
20895         TALLOC_CTX *_mem_save_job_id_0;
20896         if (flags & NDR_IN) {
20897                 ZERO_STRUCT(r->out);
20898
20899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20900                         NDR_PULL_ALLOC(ndr, r->in.handle);
20901                 }
20902                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20903                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20904                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20907                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20908                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20909                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20910                 ZERO_STRUCTP(r->out.job_id);
20911         }
20912         if (flags & NDR_OUT) {
20913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20914                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20915                 }
20916                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20917                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20920                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20921         }
20922         return NDR_ERR_SUCCESS;
20923 }
20924
20925 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20926 {
20927         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20928         ndr->depth++;
20929         if (flags & NDR_SET_VALUES) {
20930                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20931         }
20932         if (flags & NDR_IN) {
20933                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20934                 ndr->depth++;
20935                 ndr_print_ptr(ndr, "handle", r->in.handle);
20936                 ndr->depth++;
20937                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20938                 ndr->depth--;
20939                 ndr_print_uint32(ndr, "level", r->in.level);
20940                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20941                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20942                 ndr->depth--;
20943         }
20944         if (flags & NDR_OUT) {
20945                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20946                 ndr->depth++;
20947                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20948                 ndr->depth++;
20949                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20950                 ndr->depth--;
20951                 ndr_print_WERROR(ndr, "result", r->out.result);
20952                 ndr->depth--;
20953         }
20954         ndr->depth--;
20955 }
20956
20957 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20958 {
20959         if (flags & NDR_IN) {
20960                 if (r->in.handle == NULL) {
20961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20962                 }
20963                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20964         }
20965         if (flags & NDR_OUT) {
20966                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20967         }
20968         return NDR_ERR_SUCCESS;
20969 }
20970
20971 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20972 {
20973         TALLOC_CTX *_mem_save_handle_0;
20974         if (flags & NDR_IN) {
20975                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20976                         NDR_PULL_ALLOC(ndr, r->in.handle);
20977                 }
20978                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20979                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20980                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20982         }
20983         if (flags & NDR_OUT) {
20984                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20985         }
20986         return NDR_ERR_SUCCESS;
20987 }
20988
20989 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
20990 {
20991         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
20992         ndr->depth++;
20993         if (flags & NDR_SET_VALUES) {
20994                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20995         }
20996         if (flags & NDR_IN) {
20997                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
20998                 ndr->depth++;
20999                 ndr_print_ptr(ndr, "handle", r->in.handle);
21000                 ndr->depth++;
21001                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21002                 ndr->depth--;
21003                 ndr->depth--;
21004         }
21005         if (flags & NDR_OUT) {
21006                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21007                 ndr->depth++;
21008                 ndr_print_WERROR(ndr, "result", r->out.result);
21009                 ndr->depth--;
21010         }
21011         ndr->depth--;
21012 }
21013
21014 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21015 {
21016         if (flags & NDR_IN) {
21017                 if (r->in.handle == NULL) {
21018                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21019                 }
21020                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21021                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21023         }
21024         if (flags & NDR_OUT) {
21025                 if (r->out.num_written == NULL) {
21026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21027                 }
21028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21030         }
21031         return NDR_ERR_SUCCESS;
21032 }
21033
21034 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21035 {
21036         TALLOC_CTX *_mem_save_handle_0;
21037         TALLOC_CTX *_mem_save_num_written_0;
21038         if (flags & NDR_IN) {
21039                 ZERO_STRUCT(r->out);
21040
21041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21042                         NDR_PULL_ALLOC(ndr, r->in.handle);
21043                 }
21044                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21045                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21046                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21048                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21050                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21051                 ZERO_STRUCTP(r->out.num_written);
21052         }
21053         if (flags & NDR_OUT) {
21054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21055                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21056                 }
21057                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21058                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21062         }
21063         return NDR_ERR_SUCCESS;
21064 }
21065
21066 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21067 {
21068         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21069         ndr->depth++;
21070         if (flags & NDR_SET_VALUES) {
21071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21072         }
21073         if (flags & NDR_IN) {
21074                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21075                 ndr->depth++;
21076                 ndr_print_ptr(ndr, "handle", r->in.handle);
21077                 ndr->depth++;
21078                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21079                 ndr->depth--;
21080                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21081                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21082                 ndr->depth--;
21083         }
21084         if (flags & NDR_OUT) {
21085                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21086                 ndr->depth++;
21087                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21088                 ndr->depth++;
21089                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21090                 ndr->depth--;
21091                 ndr_print_WERROR(ndr, "result", r->out.result);
21092                 ndr->depth--;
21093         }
21094         ndr->depth--;
21095 }
21096
21097 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21098 {
21099         if (flags & NDR_IN) {
21100                 if (r->in.handle == NULL) {
21101                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21102                 }
21103                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21104         }
21105         if (flags & NDR_OUT) {
21106                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21107         }
21108         return NDR_ERR_SUCCESS;
21109 }
21110
21111 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21112 {
21113         TALLOC_CTX *_mem_save_handle_0;
21114         if (flags & NDR_IN) {
21115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21116                         NDR_PULL_ALLOC(ndr, r->in.handle);
21117                 }
21118                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21119                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21120                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21122         }
21123         if (flags & NDR_OUT) {
21124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21125         }
21126         return NDR_ERR_SUCCESS;
21127 }
21128
21129 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21130 {
21131         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21132         ndr->depth++;
21133         if (flags & NDR_SET_VALUES) {
21134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21135         }
21136         if (flags & NDR_IN) {
21137                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21138                 ndr->depth++;
21139                 ndr_print_ptr(ndr, "handle", r->in.handle);
21140                 ndr->depth++;
21141                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21142                 ndr->depth--;
21143                 ndr->depth--;
21144         }
21145         if (flags & NDR_OUT) {
21146                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21147                 ndr->depth++;
21148                 ndr_print_WERROR(ndr, "result", r->out.result);
21149                 ndr->depth--;
21150         }
21151         ndr->depth--;
21152 }
21153
21154 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21155 {
21156         if (flags & NDR_IN) {
21157                 if (r->in.handle == NULL) {
21158                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21159                 }
21160                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21161         }
21162         if (flags & NDR_OUT) {
21163                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21164         }
21165         return NDR_ERR_SUCCESS;
21166 }
21167
21168 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21169 {
21170         TALLOC_CTX *_mem_save_handle_0;
21171         if (flags & NDR_IN) {
21172                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21173                         NDR_PULL_ALLOC(ndr, r->in.handle);
21174                 }
21175                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21176                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21177                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21178                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21179         }
21180         if (flags & NDR_OUT) {
21181                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21182         }
21183         return NDR_ERR_SUCCESS;
21184 }
21185
21186 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21187 {
21188         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21189         ndr->depth++;
21190         if (flags & NDR_SET_VALUES) {
21191                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21192         }
21193         if (flags & NDR_IN) {
21194                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21195                 ndr->depth++;
21196                 ndr_print_ptr(ndr, "handle", r->in.handle);
21197                 ndr->depth++;
21198                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21199                 ndr->depth--;
21200                 ndr->depth--;
21201         }
21202         if (flags & NDR_OUT) {
21203                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21204                 ndr->depth++;
21205                 ndr_print_WERROR(ndr, "result", r->out.result);
21206                 ndr->depth--;
21207         }
21208         ndr->depth--;
21209 }
21210
21211 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21212 {
21213         if (flags & NDR_IN) {
21214                 if (r->in.handle == NULL) {
21215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21216                 }
21217                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21219         }
21220         if (flags & NDR_OUT) {
21221                 if (r->out.data == NULL) {
21222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21223                 }
21224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21225                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21226                 if (r->out._data_size == NULL) {
21227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21228                 }
21229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21230                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21231         }
21232         return NDR_ERR_SUCCESS;
21233 }
21234
21235 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21236 {
21237         TALLOC_CTX *_mem_save_handle_0;
21238         TALLOC_CTX *_mem_save__data_size_0;
21239         if (flags & NDR_IN) {
21240                 ZERO_STRUCT(r->out);
21241
21242                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21243                         NDR_PULL_ALLOC(ndr, r->in.handle);
21244                 }
21245                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21246                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21247                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21250                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21251                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21252                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21253                 ZERO_STRUCTP(r->out._data_size);
21254         }
21255         if (flags & NDR_OUT) {
21256                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21258                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21259                 }
21260                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21262                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21263                 }
21264                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21265                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21268                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21269                 if (r->out.data) {
21270                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21271                 }
21272         }
21273         return NDR_ERR_SUCCESS;
21274 }
21275
21276 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21277 {
21278         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21279         ndr->depth++;
21280         if (flags & NDR_SET_VALUES) {
21281                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21282         }
21283         if (flags & NDR_IN) {
21284                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21285                 ndr->depth++;
21286                 ndr_print_ptr(ndr, "handle", r->in.handle);
21287                 ndr->depth++;
21288                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21289                 ndr->depth--;
21290                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21291                 ndr->depth--;
21292         }
21293         if (flags & NDR_OUT) {
21294                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21295                 ndr->depth++;
21296                 ndr_print_ptr(ndr, "data", r->out.data);
21297                 ndr->depth++;
21298                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21299                 ndr->depth--;
21300                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21301                 ndr->depth++;
21302                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21303                 ndr->depth--;
21304                 ndr_print_WERROR(ndr, "result", r->out.result);
21305                 ndr->depth--;
21306         }
21307         ndr->depth--;
21308 }
21309
21310 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21311 {
21312         if (flags & NDR_IN) {
21313                 if (r->in.handle == NULL) {
21314                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21315                 }
21316                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21317         }
21318         if (flags & NDR_OUT) {
21319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21320         }
21321         return NDR_ERR_SUCCESS;
21322 }
21323
21324 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21325 {
21326         TALLOC_CTX *_mem_save_handle_0;
21327         if (flags & NDR_IN) {
21328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21329                         NDR_PULL_ALLOC(ndr, r->in.handle);
21330                 }
21331                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21333                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21335         }
21336         if (flags & NDR_OUT) {
21337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21338         }
21339         return NDR_ERR_SUCCESS;
21340 }
21341
21342 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21343 {
21344         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21345         ndr->depth++;
21346         if (flags & NDR_SET_VALUES) {
21347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21348         }
21349         if (flags & NDR_IN) {
21350                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21351                 ndr->depth++;
21352                 ndr_print_ptr(ndr, "handle", r->in.handle);
21353                 ndr->depth++;
21354                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21355                 ndr->depth--;
21356                 ndr->depth--;
21357         }
21358         if (flags & NDR_OUT) {
21359                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21360                 ndr->depth++;
21361                 ndr_print_WERROR(ndr, "result", r->out.result);
21362                 ndr->depth--;
21363         }
21364         ndr->depth--;
21365 }
21366
21367 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21368 {
21369         if (flags & NDR_IN) {
21370                 if (r->in.handle == NULL) {
21371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21372                 }
21373                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21376                 if (r->in.buffer) {
21377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21378                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21379                 }
21380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21381         }
21382         if (flags & NDR_OUT) {
21383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21384                 if (r->out.buffer) {
21385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21386                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21387                 }
21388                 if (r->out.needed == NULL) {
21389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21390                 }
21391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21392                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21393         }
21394         return NDR_ERR_SUCCESS;
21395 }
21396
21397 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21398 {
21399         uint32_t _ptr_buffer;
21400         TALLOC_CTX *_mem_save_handle_0;
21401         TALLOC_CTX *_mem_save_buffer_0;
21402         TALLOC_CTX *_mem_save_needed_0;
21403         if (flags & NDR_IN) {
21404                 ZERO_STRUCT(r->out);
21405
21406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21407                         NDR_PULL_ALLOC(ndr, r->in.handle);
21408                 }
21409                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21410                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21411                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21415                 if (_ptr_buffer) {
21416                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21417                 } else {
21418                         r->in.buffer = NULL;
21419                 }
21420                 if (r->in.buffer) {
21421                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21422                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21424                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21425                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21427                 }
21428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21429                 NDR_PULL_ALLOC(ndr, r->out.needed);
21430                 ZERO_STRUCTP(r->out.needed);
21431                 if (r->in.buffer) {
21432                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21433                 }
21434         }
21435         if (flags & NDR_OUT) {
21436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21437                 if (_ptr_buffer) {
21438                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21439                 } else {
21440                         r->out.buffer = NULL;
21441                 }
21442                 if (r->out.buffer) {
21443                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21444                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21445                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21446                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21447                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21449                 }
21450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21451                         NDR_PULL_ALLOC(ndr, r->out.needed);
21452                 }
21453                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21454                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21457                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21458                 if (r->out.buffer) {
21459                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21460                 }
21461         }
21462         return NDR_ERR_SUCCESS;
21463 }
21464
21465 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21466 {
21467         ndr_print_struct(ndr, name, "spoolss_AddJob");
21468         ndr->depth++;
21469         if (flags & NDR_SET_VALUES) {
21470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21471         }
21472         if (flags & NDR_IN) {
21473                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21474                 ndr->depth++;
21475                 ndr_print_ptr(ndr, "handle", r->in.handle);
21476                 ndr->depth++;
21477                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21478                 ndr->depth--;
21479                 ndr_print_uint32(ndr, "level", r->in.level);
21480                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21481                 ndr->depth++;
21482                 if (r->in.buffer) {
21483                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21484                 }
21485                 ndr->depth--;
21486                 ndr_print_uint32(ndr, "offered", r->in.offered);
21487                 ndr->depth--;
21488         }
21489         if (flags & NDR_OUT) {
21490                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21491                 ndr->depth++;
21492                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21493                 ndr->depth++;
21494                 if (r->out.buffer) {
21495                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21496                 }
21497                 ndr->depth--;
21498                 ndr_print_ptr(ndr, "needed", r->out.needed);
21499                 ndr->depth++;
21500                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21501                 ndr->depth--;
21502                 ndr_print_WERROR(ndr, "result", r->out.result);
21503                 ndr->depth--;
21504         }
21505         ndr->depth--;
21506 }
21507
21508 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21509 {
21510         if (flags & NDR_IN) {
21511                 if (r->in.handle == NULL) {
21512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21513                 }
21514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21516         }
21517         if (flags & NDR_OUT) {
21518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21519         }
21520         return NDR_ERR_SUCCESS;
21521 }
21522
21523 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21524 {
21525         TALLOC_CTX *_mem_save_handle_0;
21526         if (flags & NDR_IN) {
21527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21528                         NDR_PULL_ALLOC(ndr, r->in.handle);
21529                 }
21530                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21531                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21532                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21535         }
21536         if (flags & NDR_OUT) {
21537                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21538         }
21539         return NDR_ERR_SUCCESS;
21540 }
21541
21542 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21543 {
21544         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21545         ndr->depth++;
21546         if (flags & NDR_SET_VALUES) {
21547                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21548         }
21549         if (flags & NDR_IN) {
21550                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21551                 ndr->depth++;
21552                 ndr_print_ptr(ndr, "handle", r->in.handle);
21553                 ndr->depth++;
21554                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21555                 ndr->depth--;
21556                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21557                 ndr->depth--;
21558         }
21559         if (flags & NDR_OUT) {
21560                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21561                 ndr->depth++;
21562                 ndr_print_WERROR(ndr, "result", r->out.result);
21563                 ndr->depth--;
21564         }
21565         ndr->depth--;
21566 }
21567
21568 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21569 {
21570         if (flags & NDR_IN) {
21571                 if (r->in.handle == NULL) {
21572                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21573                 }
21574                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21578                 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));
21579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21580         }
21581         if (flags & NDR_OUT) {
21582                 if (r->out.type == NULL) {
21583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21584                 }
21585                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
21586                 if (r->out.data == NULL) {
21587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21588                 }
21589                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
21590                 if (r->out.needed == NULL) {
21591                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21592                 }
21593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21595         }
21596         return NDR_ERR_SUCCESS;
21597 }
21598
21599 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21600 {
21601         TALLOC_CTX *_mem_save_handle_0;
21602         TALLOC_CTX *_mem_save_type_0;
21603         TALLOC_CTX *_mem_save_data_0;
21604         TALLOC_CTX *_mem_save_needed_0;
21605         if (flags & NDR_IN) {
21606                 ZERO_STRUCT(r->out);
21607
21608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21609                         NDR_PULL_ALLOC(ndr, r->in.handle);
21610                 }
21611                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21613                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21615                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21616                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21617                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21618                         return 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));
21619                 }
21620                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21621                 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));
21622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21623                 NDR_PULL_ALLOC(ndr, r->out.type);
21624                 ZERO_STRUCTP(r->out.type);
21625                 NDR_PULL_ALLOC(ndr, r->out.data);
21626                 ZERO_STRUCTP(r->out.data);
21627                 NDR_PULL_ALLOC(ndr, r->out.needed);
21628                 ZERO_STRUCTP(r->out.needed);
21629         }
21630         if (flags & NDR_OUT) {
21631                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21632                         NDR_PULL_ALLOC(ndr, r->out.type);
21633                 }
21634                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21635                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21636                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
21637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21639                         NDR_PULL_ALLOC(ndr, r->out.data);
21640                 }
21641                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21642                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21643                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21646                         NDR_PULL_ALLOC(ndr, r->out.needed);
21647                 }
21648                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21649                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21653         }
21654         return NDR_ERR_SUCCESS;
21655 }
21656
21657 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21658 {
21659         if (flags & NDR_IN) {
21660                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21661         }
21662         if (flags & NDR_OUT) {
21663                 if (r->out.data == NULL) {
21664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21665                 }
21666                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21667                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21668         }
21669         return NDR_ERR_SUCCESS;
21670 }
21671
21672 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21673 {
21674         TALLOC_CTX *_mem_save_data_0;
21675         if (flags & NDR_IN) {
21676                 ZERO_STRUCT(r->out);
21677
21678                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21679                 NDR_PULL_ALLOC(ndr, r->out.data);
21680                 ZERO_STRUCTP(r->out.data);
21681         }
21682         if (flags & NDR_OUT) {
21683                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21684                         NDR_PULL_ALLOC(ndr, r->out.data);
21685                 }
21686                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21687                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21688                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
21689                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21690                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21691         }
21692         return NDR_ERR_SUCCESS;
21693 }
21694
21695 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21696 {
21697         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21698         ndr->depth++;
21699         if (flags & NDR_SET_VALUES) {
21700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21701         }
21702         if (flags & NDR_IN) {
21703                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21704                 ndr->depth++;
21705                 ndr_print_ptr(ndr, "handle", r->in.handle);
21706                 ndr->depth++;
21707                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21708                 ndr->depth--;
21709                 ndr_print_string(ndr, "value_name", r->in.value_name);
21710                 ndr_print_uint32(ndr, "offered", r->in.offered);
21711                 ndr->depth--;
21712         }
21713         if (flags & NDR_OUT) {
21714                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21715                 ndr->depth++;
21716                 ndr_print_ptr(ndr, "type", r->out.type);
21717                 ndr->depth++;
21718                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
21719                 ndr->depth--;
21720                 ndr_print_ptr(ndr, "data", r->out.data);
21721                 ndr->depth++;
21722                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
21723                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
21724                 ndr->depth--;
21725                 ndr_print_ptr(ndr, "needed", r->out.needed);
21726                 ndr->depth++;
21727                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21728                 ndr->depth--;
21729                 ndr_print_WERROR(ndr, "result", r->out.result);
21730                 ndr->depth--;
21731         }
21732         ndr->depth--;
21733 }
21734
21735 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21736 {
21737         if (flags & NDR_IN) {
21738                 if (r->in.handle == NULL) {
21739                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21740                 }
21741                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21745                 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));
21746                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21747                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21749         }
21750         if (flags & NDR_OUT) {
21751                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21752         }
21753         return NDR_ERR_SUCCESS;
21754 }
21755
21756 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21757 {
21758         if (flags & NDR_IN) {
21759                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21760         }
21761         if (flags & NDR_OUT) {
21762                 if (r->out.data == NULL) {
21763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21764                 }
21765                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21766                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21767         }
21768         return NDR_ERR_SUCCESS;
21769 }
21770
21771 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21772 {
21773         TALLOC_CTX *_mem_save_handle_0;
21774         if (flags & NDR_IN) {
21775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21776                         NDR_PULL_ALLOC(ndr, r->in.handle);
21777                 }
21778                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21779                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21780                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21782                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21783                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21784                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21785                         return 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));
21786                 }
21787                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21788                 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));
21789                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21790                 {
21791                         struct ndr_pull *_ndr_data;
21792                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21793                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21794                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21795                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21796                 }
21797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21798         }
21799         if (flags & NDR_OUT) {
21800                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21801         }
21802         return NDR_ERR_SUCCESS;
21803 }
21804
21805 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21806 {
21807         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21808         ndr->depth++;
21809         if (flags & NDR_SET_VALUES) {
21810                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21811         }
21812         if (flags & NDR_IN) {
21813                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21814                 ndr->depth++;
21815                 ndr_print_ptr(ndr, "handle", r->in.handle);
21816                 ndr->depth++;
21817                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21818                 ndr->depth--;
21819                 ndr_print_string(ndr, "value_name", r->in.value_name);
21820                 ndr_print_winreg_Type(ndr, "type", r->in.type);
21821                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21822                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21823                 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);
21824                 ndr->depth--;
21825         }
21826         if (flags & NDR_OUT) {
21827                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21828                 ndr->depth++;
21829                 ndr_print_WERROR(ndr, "result", r->out.result);
21830                 ndr->depth--;
21831         }
21832         ndr->depth--;
21833 }
21834
21835 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21836 {
21837         if (flags & NDR_IN) {
21838         }
21839         if (flags & NDR_OUT) {
21840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21841         }
21842         return NDR_ERR_SUCCESS;
21843 }
21844
21845 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21846 {
21847         if (flags & NDR_IN) {
21848         }
21849         if (flags & NDR_OUT) {
21850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21851         }
21852         return NDR_ERR_SUCCESS;
21853 }
21854
21855 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21856 {
21857         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21858         ndr->depth++;
21859         if (flags & NDR_SET_VALUES) {
21860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21861         }
21862         if (flags & NDR_IN) {
21863                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21864                 ndr->depth++;
21865                 ndr->depth--;
21866         }
21867         if (flags & NDR_OUT) {
21868                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21869                 ndr->depth++;
21870                 ndr_print_WERROR(ndr, "result", r->out.result);
21871                 ndr->depth--;
21872         }
21873         ndr->depth--;
21874 }
21875
21876 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21877 {
21878         if (flags & NDR_IN) {
21879                 if (r->in.handle == NULL) {
21880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21881                 }
21882                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21883         }
21884         if (flags & NDR_OUT) {
21885                 if (r->out.handle == NULL) {
21886                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21887                 }
21888                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21890         }
21891         return NDR_ERR_SUCCESS;
21892 }
21893
21894 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21895 {
21896         TALLOC_CTX *_mem_save_handle_0;
21897         if (flags & NDR_IN) {
21898                 ZERO_STRUCT(r->out);
21899
21900                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21901                         NDR_PULL_ALLOC(ndr, r->in.handle);
21902                 }
21903                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21904                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21905                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21907                 NDR_PULL_ALLOC(ndr, r->out.handle);
21908                 *r->out.handle = *r->in.handle;
21909         }
21910         if (flags & NDR_OUT) {
21911                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21912                         NDR_PULL_ALLOC(ndr, r->out.handle);
21913                 }
21914                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21915                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21916                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21917                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21918                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21919         }
21920         return NDR_ERR_SUCCESS;
21921 }
21922
21923 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21924 {
21925         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21926         ndr->depth++;
21927         if (flags & NDR_SET_VALUES) {
21928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21929         }
21930         if (flags & NDR_IN) {
21931                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21932                 ndr->depth++;
21933                 ndr_print_ptr(ndr, "handle", r->in.handle);
21934                 ndr->depth++;
21935                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21936                 ndr->depth--;
21937                 ndr->depth--;
21938         }
21939         if (flags & NDR_OUT) {
21940                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21941                 ndr->depth++;
21942                 ndr_print_ptr(ndr, "handle", r->out.handle);
21943                 ndr->depth++;
21944                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21945                 ndr->depth--;
21946                 ndr_print_WERROR(ndr, "result", r->out.result);
21947                 ndr->depth--;
21948         }
21949         ndr->depth--;
21950 }
21951
21952 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21953 {
21954         if (flags & NDR_IN) {
21955                 if (r->in.handle == NULL) {
21956                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21957                 }
21958                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21960                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21961                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21962         }
21963         if (flags & NDR_OUT) {
21964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21965         }
21966         return NDR_ERR_SUCCESS;
21967 }
21968
21969 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21970 {
21971         TALLOC_CTX *_mem_save_handle_0;
21972         if (flags & NDR_IN) {
21973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21974                         NDR_PULL_ALLOC(ndr, r->in.handle);
21975                 }
21976                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21978                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21981                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21982                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21983         }
21984         if (flags & NDR_OUT) {
21985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21986         }
21987         return NDR_ERR_SUCCESS;
21988 }
21989
21990 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21991 {
21992         ndr_print_struct(ndr, name, "spoolss_AddForm");
21993         ndr->depth++;
21994         if (flags & NDR_SET_VALUES) {
21995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21996         }
21997         if (flags & NDR_IN) {
21998                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21999                 ndr->depth++;
22000                 ndr_print_ptr(ndr, "handle", r->in.handle);
22001                 ndr->depth++;
22002                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22003                 ndr->depth--;
22004                 ndr_print_uint32(ndr, "level", r->in.level);
22005                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22006                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22007                 ndr->depth--;
22008         }
22009         if (flags & NDR_OUT) {
22010                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22011                 ndr->depth++;
22012                 ndr_print_WERROR(ndr, "result", r->out.result);
22013                 ndr->depth--;
22014         }
22015         ndr->depth--;
22016 }
22017
22018 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22019 {
22020         if (flags & NDR_IN) {
22021                 if (r->in.handle == NULL) {
22022                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22023                 }
22024                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22028                 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));
22029         }
22030         if (flags & NDR_OUT) {
22031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22032         }
22033         return NDR_ERR_SUCCESS;
22034 }
22035
22036 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22037 {
22038         TALLOC_CTX *_mem_save_handle_0;
22039         if (flags & NDR_IN) {
22040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22041                         NDR_PULL_ALLOC(ndr, r->in.handle);
22042                 }
22043                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22044                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22045                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22046                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22047                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22048                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22049                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22050                         return 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));
22051                 }
22052                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22053                 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));
22054         }
22055         if (flags & NDR_OUT) {
22056                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22057         }
22058         return NDR_ERR_SUCCESS;
22059 }
22060
22061 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22062 {
22063         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22064         ndr->depth++;
22065         if (flags & NDR_SET_VALUES) {
22066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22067         }
22068         if (flags & NDR_IN) {
22069                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22070                 ndr->depth++;
22071                 ndr_print_ptr(ndr, "handle", r->in.handle);
22072                 ndr->depth++;
22073                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22074                 ndr->depth--;
22075                 ndr_print_string(ndr, "form_name", r->in.form_name);
22076                 ndr->depth--;
22077         }
22078         if (flags & NDR_OUT) {
22079                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22080                 ndr->depth++;
22081                 ndr_print_WERROR(ndr, "result", r->out.result);
22082                 ndr->depth--;
22083         }
22084         ndr->depth--;
22085 }
22086
22087 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22088 {
22089         if (flags & NDR_IN) {
22090                 if (r->in.handle == NULL) {
22091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22092                 }
22093                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22097                 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));
22098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22100                 if (r->in.buffer) {
22101                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22102                 }
22103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22104         }
22105         if (flags & NDR_OUT) {
22106                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22107                 if (r->out.info) {
22108                         {
22109                                 struct ndr_push *_ndr_info;
22110                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22111                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22112                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22113                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22114                         }
22115                 }
22116                 if (r->out.needed == NULL) {
22117                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22118                 }
22119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22120                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22121         }
22122         return NDR_ERR_SUCCESS;
22123 }
22124
22125 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22126 {
22127         uint32_t _ptr_buffer;
22128         uint32_t _ptr_info;
22129         TALLOC_CTX *_mem_save_handle_0;
22130         TALLOC_CTX *_mem_save_buffer_0;
22131         TALLOC_CTX *_mem_save_info_0;
22132         TALLOC_CTX *_mem_save_needed_0;
22133         if (flags & NDR_IN) {
22134                 ZERO_STRUCT(r->out);
22135
22136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22137                         NDR_PULL_ALLOC(ndr, r->in.handle);
22138                 }
22139                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22140                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22141                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22143                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22144                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22145                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22146                         return 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));
22147                 }
22148                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22149                 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));
22150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22152                 if (_ptr_buffer) {
22153                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22154                 } else {
22155                         r->in.buffer = NULL;
22156                 }
22157                 if (r->in.buffer) {
22158                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22159                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22160                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22162                 }
22163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22164                 NDR_PULL_ALLOC(ndr, r->out.needed);
22165                 ZERO_STRUCTP(r->out.needed);
22166         }
22167         if (flags & NDR_OUT) {
22168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22169                 if (_ptr_info) {
22170                         NDR_PULL_ALLOC(ndr, r->out.info);
22171                 } else {
22172                         r->out.info = NULL;
22173                 }
22174                 if (r->out.info) {
22175                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22176                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22177                         {
22178                                 struct ndr_pull *_ndr_info;
22179                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22180                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22181                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22182                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22183                         }
22184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22185                 }
22186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22187                         NDR_PULL_ALLOC(ndr, r->out.needed);
22188                 }
22189                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22190                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22192                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22194         }
22195         return NDR_ERR_SUCCESS;
22196 }
22197
22198 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22199 {
22200         ndr_print_struct(ndr, name, "spoolss_GetForm");
22201         ndr->depth++;
22202         if (flags & NDR_SET_VALUES) {
22203                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22204         }
22205         if (flags & NDR_IN) {
22206                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22207                 ndr->depth++;
22208                 ndr_print_ptr(ndr, "handle", r->in.handle);
22209                 ndr->depth++;
22210                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22211                 ndr->depth--;
22212                 ndr_print_string(ndr, "form_name", r->in.form_name);
22213                 ndr_print_uint32(ndr, "level", r->in.level);
22214                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22215                 ndr->depth++;
22216                 if (r->in.buffer) {
22217                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22218                 }
22219                 ndr->depth--;
22220                 ndr_print_uint32(ndr, "offered", r->in.offered);
22221                 ndr->depth--;
22222         }
22223         if (flags & NDR_OUT) {
22224                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22225                 ndr->depth++;
22226                 ndr_print_ptr(ndr, "info", r->out.info);
22227                 ndr->depth++;
22228                 if (r->out.info) {
22229                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22230                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22231                 }
22232                 ndr->depth--;
22233                 ndr_print_ptr(ndr, "needed", r->out.needed);
22234                 ndr->depth++;
22235                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22236                 ndr->depth--;
22237                 ndr_print_WERROR(ndr, "result", r->out.result);
22238                 ndr->depth--;
22239         }
22240         ndr->depth--;
22241 }
22242
22243 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22244 {
22245         if (flags & NDR_IN) {
22246                 if (r->in.handle == NULL) {
22247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22248                 }
22249                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22253                 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));
22254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22255                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22256                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22257         }
22258         if (flags & NDR_OUT) {
22259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22260         }
22261         return NDR_ERR_SUCCESS;
22262 }
22263
22264 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22265 {
22266         TALLOC_CTX *_mem_save_handle_0;
22267         if (flags & NDR_IN) {
22268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22269                         NDR_PULL_ALLOC(ndr, r->in.handle);
22270                 }
22271                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22272                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22273                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22275                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22276                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22277                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22278                         return 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));
22279                 }
22280                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22281                 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));
22282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22283                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22284                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22285         }
22286         if (flags & NDR_OUT) {
22287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22288         }
22289         return NDR_ERR_SUCCESS;
22290 }
22291
22292 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22293 {
22294         ndr_print_struct(ndr, name, "spoolss_SetForm");
22295         ndr->depth++;
22296         if (flags & NDR_SET_VALUES) {
22297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22298         }
22299         if (flags & NDR_IN) {
22300                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22301                 ndr->depth++;
22302                 ndr_print_ptr(ndr, "handle", r->in.handle);
22303                 ndr->depth++;
22304                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22305                 ndr->depth--;
22306                 ndr_print_string(ndr, "form_name", r->in.form_name);
22307                 ndr_print_uint32(ndr, "level", r->in.level);
22308                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22309                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22310                 ndr->depth--;
22311         }
22312         if (flags & NDR_OUT) {
22313                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22314                 ndr->depth++;
22315                 ndr_print_WERROR(ndr, "result", r->out.result);
22316                 ndr->depth--;
22317         }
22318         ndr->depth--;
22319 }
22320
22321 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22322 {
22323         if (flags & NDR_IN) {
22324                 if (r->in.handle == NULL) {
22325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22326                 }
22327                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22330                 if (r->in.buffer) {
22331                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22332                 }
22333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22334         }
22335         if (flags & NDR_OUT) {
22336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22337                 if (r->out.info) {
22338                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22339                 }
22340                 if (r->out.needed == NULL) {
22341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22342                 }
22343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22344                 if (r->out.count == NULL) {
22345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22346                 }
22347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22349         }
22350         return NDR_ERR_SUCCESS;
22351 }
22352
22353 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22354 {
22355         uint32_t _ptr_buffer;
22356         uint32_t _ptr_info;
22357         TALLOC_CTX *_mem_save_handle_0;
22358         TALLOC_CTX *_mem_save_buffer_0;
22359         TALLOC_CTX *_mem_save_info_0;
22360         TALLOC_CTX *_mem_save_needed_0;
22361         TALLOC_CTX *_mem_save_count_0;
22362         if (flags & NDR_IN) {
22363                 ZERO_STRUCT(r->out);
22364
22365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22366                         NDR_PULL_ALLOC(ndr, r->in.handle);
22367                 }
22368                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22373                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22374                 if (_ptr_buffer) {
22375                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22376                 } else {
22377                         r->in.buffer = NULL;
22378                 }
22379                 if (r->in.buffer) {
22380                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22381                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22382                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22384                 }
22385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22386                 NDR_PULL_ALLOC(ndr, r->out.needed);
22387                 ZERO_STRUCTP(r->out.needed);
22388                 NDR_PULL_ALLOC(ndr, r->out.count);
22389                 ZERO_STRUCTP(r->out.count);
22390         }
22391         if (flags & NDR_OUT) {
22392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22393                 if (_ptr_info) {
22394                         NDR_PULL_ALLOC(ndr, r->out.info);
22395                 } else {
22396                         r->out.info = NULL;
22397                 }
22398                 if (r->out.info) {
22399                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22400                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22401                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22403                 }
22404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22405                         NDR_PULL_ALLOC(ndr, r->out.needed);
22406                 }
22407                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22408                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22411                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22412                         NDR_PULL_ALLOC(ndr, r->out.count);
22413                 }
22414                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22415                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22418                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22419         }
22420         return NDR_ERR_SUCCESS;
22421 }
22422
22423 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22424 {
22425         uint32_t cntr_info_0;
22426         if (flags & NDR_IN) {
22427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22429         }
22430         if (flags & NDR_OUT) {
22431                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22432                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22433                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22434                 }
22435                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22436                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22437                 }
22438         }
22439         return NDR_ERR_SUCCESS;
22440 }
22441
22442 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22443 {
22444         uint32_t cntr_info_0;
22445         TALLOC_CTX *_mem_save_info_0;
22446         if (flags & NDR_IN) {
22447                 ZERO_STRUCT(r->out);
22448
22449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22451         }
22452         if (flags & NDR_OUT) {
22453                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22454                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22456                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22457                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22458                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22459                 }
22460                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22461                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22462                 }
22463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22464         }
22465         return NDR_ERR_SUCCESS;
22466 }
22467
22468 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22469 {
22470         uint32_t cntr_info_2;
22471         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22472         ndr->depth++;
22473         if (flags & NDR_SET_VALUES) {
22474                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22475         }
22476         if (flags & NDR_IN) {
22477                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22478                 ndr->depth++;
22479                 ndr_print_ptr(ndr, "handle", r->in.handle);
22480                 ndr->depth++;
22481                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22482                 ndr->depth--;
22483                 ndr_print_uint32(ndr, "level", r->in.level);
22484                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22485                 ndr->depth++;
22486                 if (r->in.buffer) {
22487                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22488                 }
22489                 ndr->depth--;
22490                 ndr_print_uint32(ndr, "offered", r->in.offered);
22491                 ndr->depth--;
22492         }
22493         if (flags & NDR_OUT) {
22494                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22495                 ndr->depth++;
22496                 ndr_print_ptr(ndr, "count", r->out.count);
22497                 ndr->depth++;
22498                 ndr_print_uint32(ndr, "count", *r->out.count);
22499                 ndr->depth--;
22500                 ndr_print_ptr(ndr, "info", r->out.info);
22501                 ndr->depth++;
22502                 ndr_print_ptr(ndr, "info", *r->out.info);
22503                 ndr->depth++;
22504                 if (*r->out.info) {
22505                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22506                         ndr->depth++;
22507                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22508                                 char *idx_2=NULL;
22509                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22510                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22511                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22512                                         free(idx_2);
22513                                 }
22514                         }
22515                         ndr->depth--;
22516                 }
22517                 ndr->depth--;
22518                 ndr->depth--;
22519                 ndr_print_ptr(ndr, "needed", r->out.needed);
22520                 ndr->depth++;
22521                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22522                 ndr->depth--;
22523                 ndr_print_WERROR(ndr, "result", r->out.result);
22524                 ndr->depth--;
22525         }
22526         ndr->depth--;
22527 }
22528
22529 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22530 {
22531         if (flags & NDR_IN) {
22532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22533                 if (r->in.servername) {
22534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22535                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22537                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22538                 }
22539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22541                 if (r->in.buffer) {
22542                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22543                 }
22544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22545         }
22546         if (flags & NDR_OUT) {
22547                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22548                 if (r->out.info) {
22549                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22550                 }
22551                 if (r->out.needed == NULL) {
22552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22553                 }
22554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22555                 if (r->out.count == NULL) {
22556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22557                 }
22558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22559                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22560         }
22561         return NDR_ERR_SUCCESS;
22562 }
22563
22564 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22565 {
22566         uint32_t _ptr_servername;
22567         uint32_t _ptr_buffer;
22568         uint32_t _ptr_info;
22569         TALLOC_CTX *_mem_save_servername_0;
22570         TALLOC_CTX *_mem_save_buffer_0;
22571         TALLOC_CTX *_mem_save_info_0;
22572         TALLOC_CTX *_mem_save_needed_0;
22573         TALLOC_CTX *_mem_save_count_0;
22574         if (flags & NDR_IN) {
22575                 ZERO_STRUCT(r->out);
22576
22577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22578                 if (_ptr_servername) {
22579                         NDR_PULL_ALLOC(ndr, r->in.servername);
22580                 } else {
22581                         r->in.servername = NULL;
22582                 }
22583                 if (r->in.servername) {
22584                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22585                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22588                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22589                                 return 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));
22590                         }
22591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22594                 }
22595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22596                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22597                 if (_ptr_buffer) {
22598                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22599                 } else {
22600                         r->in.buffer = NULL;
22601                 }
22602                 if (r->in.buffer) {
22603                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22604                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22605                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22607                 }
22608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22609                 NDR_PULL_ALLOC(ndr, r->out.needed);
22610                 ZERO_STRUCTP(r->out.needed);
22611                 NDR_PULL_ALLOC(ndr, r->out.count);
22612                 ZERO_STRUCTP(r->out.count);
22613         }
22614         if (flags & NDR_OUT) {
22615                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22616                 if (_ptr_info) {
22617                         NDR_PULL_ALLOC(ndr, r->out.info);
22618                 } else {
22619                         r->out.info = NULL;
22620                 }
22621                 if (r->out.info) {
22622                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22623                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22624                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22625                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22626                 }
22627                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22628                         NDR_PULL_ALLOC(ndr, r->out.needed);
22629                 }
22630                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22631                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22633                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22635                         NDR_PULL_ALLOC(ndr, r->out.count);
22636                 }
22637                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22638                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22641                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22642         }
22643         return NDR_ERR_SUCCESS;
22644 }
22645
22646 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22647 {
22648         uint32_t cntr_info_0;
22649         if (flags & NDR_IN) {
22650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22652         }
22653         if (flags & NDR_OUT) {
22654                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22655                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22656                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22657                 }
22658                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22659                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22660                 }
22661         }
22662         return NDR_ERR_SUCCESS;
22663 }
22664
22665 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22666 {
22667         uint32_t cntr_info_0;
22668         TALLOC_CTX *_mem_save_info_0;
22669         if (flags & NDR_IN) {
22670                 ZERO_STRUCT(r->out);
22671
22672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22674         }
22675         if (flags & NDR_OUT) {
22676                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22677                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22679                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22680                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22681                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22682                 }
22683                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22684                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22685                 }
22686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22687         }
22688         return NDR_ERR_SUCCESS;
22689 }
22690
22691 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22692 {
22693         uint32_t cntr_info_2;
22694         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22695         ndr->depth++;
22696         if (flags & NDR_SET_VALUES) {
22697                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22698         }
22699         if (flags & NDR_IN) {
22700                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22701                 ndr->depth++;
22702                 ndr_print_ptr(ndr, "servername", r->in.servername);
22703                 ndr->depth++;
22704                 if (r->in.servername) {
22705                         ndr_print_string(ndr, "servername", r->in.servername);
22706                 }
22707                 ndr->depth--;
22708                 ndr_print_uint32(ndr, "level", r->in.level);
22709                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22710                 ndr->depth++;
22711                 if (r->in.buffer) {
22712                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22713                 }
22714                 ndr->depth--;
22715                 ndr_print_uint32(ndr, "offered", r->in.offered);
22716                 ndr->depth--;
22717         }
22718         if (flags & NDR_OUT) {
22719                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22720                 ndr->depth++;
22721                 ndr_print_ptr(ndr, "count", r->out.count);
22722                 ndr->depth++;
22723                 ndr_print_uint32(ndr, "count", *r->out.count);
22724                 ndr->depth--;
22725                 ndr_print_ptr(ndr, "info", r->out.info);
22726                 ndr->depth++;
22727                 ndr_print_ptr(ndr, "info", *r->out.info);
22728                 ndr->depth++;
22729                 if (*r->out.info) {
22730                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22731                         ndr->depth++;
22732                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22733                                 char *idx_2=NULL;
22734                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22735                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22736                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22737                                         free(idx_2);
22738                                 }
22739                         }
22740                         ndr->depth--;
22741                 }
22742                 ndr->depth--;
22743                 ndr->depth--;
22744                 ndr_print_ptr(ndr, "needed", r->out.needed);
22745                 ndr->depth++;
22746                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22747                 ndr->depth--;
22748                 ndr_print_WERROR(ndr, "result", r->out.result);
22749                 ndr->depth--;
22750         }
22751         ndr->depth--;
22752 }
22753
22754 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22755 {
22756         if (flags & NDR_IN) {
22757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22758                 if (r->in.servername) {
22759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22762                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22763                 }
22764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22766                 if (r->in.buffer) {
22767                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22768                 }
22769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22770         }
22771         if (flags & NDR_OUT) {
22772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22773                 if (r->out.info) {
22774                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22775                 }
22776                 if (r->out.needed == NULL) {
22777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22778                 }
22779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22780                 if (r->out.count == NULL) {
22781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22782                 }
22783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22784                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22785         }
22786         return NDR_ERR_SUCCESS;
22787 }
22788
22789 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22790 {
22791         uint32_t _ptr_servername;
22792         uint32_t _ptr_buffer;
22793         uint32_t _ptr_info;
22794         TALLOC_CTX *_mem_save_servername_0;
22795         TALLOC_CTX *_mem_save_buffer_0;
22796         TALLOC_CTX *_mem_save_info_0;
22797         TALLOC_CTX *_mem_save_needed_0;
22798         TALLOC_CTX *_mem_save_count_0;
22799         if (flags & NDR_IN) {
22800                 ZERO_STRUCT(r->out);
22801
22802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22803                 if (_ptr_servername) {
22804                         NDR_PULL_ALLOC(ndr, r->in.servername);
22805                 } else {
22806                         r->in.servername = NULL;
22807                 }
22808                 if (r->in.servername) {
22809                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22812                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22813                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22814                                 return 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));
22815                         }
22816                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22817                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22818                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22819                 }
22820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22822                 if (_ptr_buffer) {
22823                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22824                 } else {
22825                         r->in.buffer = NULL;
22826                 }
22827                 if (r->in.buffer) {
22828                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22829                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22830                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22831                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22832                 }
22833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22834                 NDR_PULL_ALLOC(ndr, r->out.needed);
22835                 ZERO_STRUCTP(r->out.needed);
22836                 NDR_PULL_ALLOC(ndr, r->out.count);
22837                 ZERO_STRUCTP(r->out.count);
22838         }
22839         if (flags & NDR_OUT) {
22840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22841                 if (_ptr_info) {
22842                         NDR_PULL_ALLOC(ndr, r->out.info);
22843                 } else {
22844                         r->out.info = NULL;
22845                 }
22846                 if (r->out.info) {
22847                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22848                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22849                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22851                 }
22852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22853                         NDR_PULL_ALLOC(ndr, r->out.needed);
22854                 }
22855                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22856                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22860                         NDR_PULL_ALLOC(ndr, r->out.count);
22861                 }
22862                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22867         }
22868         return NDR_ERR_SUCCESS;
22869 }
22870
22871 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22872 {
22873         uint32_t cntr_info_0;
22874         if (flags & NDR_IN) {
22875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22877         }
22878         if (flags & NDR_OUT) {
22879                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22880                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22881                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22882                 }
22883                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22884                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22885                 }
22886         }
22887         return NDR_ERR_SUCCESS;
22888 }
22889
22890 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22891 {
22892         uint32_t cntr_info_0;
22893         TALLOC_CTX *_mem_save_info_0;
22894         if (flags & NDR_IN) {
22895                 ZERO_STRUCT(r->out);
22896
22897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22899         }
22900         if (flags & NDR_OUT) {
22901                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22902                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22903                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22904                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22905                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22906                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22907                 }
22908                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22909                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22910                 }
22911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22912         }
22913         return NDR_ERR_SUCCESS;
22914 }
22915
22916 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22917 {
22918         uint32_t cntr_info_2;
22919         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22920         ndr->depth++;
22921         if (flags & NDR_SET_VALUES) {
22922                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22923         }
22924         if (flags & NDR_IN) {
22925                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22926                 ndr->depth++;
22927                 ndr_print_ptr(ndr, "servername", r->in.servername);
22928                 ndr->depth++;
22929                 if (r->in.servername) {
22930                         ndr_print_string(ndr, "servername", r->in.servername);
22931                 }
22932                 ndr->depth--;
22933                 ndr_print_uint32(ndr, "level", r->in.level);
22934                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22935                 ndr->depth++;
22936                 if (r->in.buffer) {
22937                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22938                 }
22939                 ndr->depth--;
22940                 ndr_print_uint32(ndr, "offered", r->in.offered);
22941                 ndr->depth--;
22942         }
22943         if (flags & NDR_OUT) {
22944                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22945                 ndr->depth++;
22946                 ndr_print_ptr(ndr, "count", r->out.count);
22947                 ndr->depth++;
22948                 ndr_print_uint32(ndr, "count", *r->out.count);
22949                 ndr->depth--;
22950                 ndr_print_ptr(ndr, "info", r->out.info);
22951                 ndr->depth++;
22952                 ndr_print_ptr(ndr, "info", *r->out.info);
22953                 ndr->depth++;
22954                 if (*r->out.info) {
22955                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22956                         ndr->depth++;
22957                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22958                                 char *idx_2=NULL;
22959                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22960                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22961                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22962                                         free(idx_2);
22963                                 }
22964                         }
22965                         ndr->depth--;
22966                 }
22967                 ndr->depth--;
22968                 ndr->depth--;
22969                 ndr_print_ptr(ndr, "needed", r->out.needed);
22970                 ndr->depth++;
22971                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22972                 ndr->depth--;
22973                 ndr_print_WERROR(ndr, "result", r->out.result);
22974                 ndr->depth--;
22975         }
22976         ndr->depth--;
22977 }
22978
22979 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22980 {
22981         if (flags & NDR_IN) {
22982                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22983                 if (r->in.server_name) {
22984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22987                         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));
22988                 }
22989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22993                 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));
22994         }
22995         if (flags & NDR_OUT) {
22996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22997         }
22998         return NDR_ERR_SUCCESS;
22999 }
23000
23001 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23002 {
23003         uint32_t _ptr_server_name;
23004         TALLOC_CTX *_mem_save_server_name_0;
23005         if (flags & NDR_IN) {
23006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23007                 if (_ptr_server_name) {
23008                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23009                 } else {
23010                         r->in.server_name = NULL;
23011                 }
23012                 if (r->in.server_name) {
23013                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23014                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23015                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23016                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23017                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23018                                 return 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));
23019                         }
23020                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23021                         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));
23022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23023                 }
23024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23025                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23026                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23027                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23028                         return 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));
23029                 }
23030                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23031                 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));
23032         }
23033         if (flags & NDR_OUT) {
23034                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23035         }
23036         return NDR_ERR_SUCCESS;
23037 }
23038
23039 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23040 {
23041         ndr_print_struct(ndr, name, "spoolss_AddPort");
23042         ndr->depth++;
23043         if (flags & NDR_SET_VALUES) {
23044                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23045         }
23046         if (flags & NDR_IN) {
23047                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23048                 ndr->depth++;
23049                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23050                 ndr->depth++;
23051                 if (r->in.server_name) {
23052                         ndr_print_string(ndr, "server_name", r->in.server_name);
23053                 }
23054                 ndr->depth--;
23055                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23056                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23057                 ndr->depth--;
23058         }
23059         if (flags & NDR_OUT) {
23060                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23061                 ndr->depth++;
23062                 ndr_print_WERROR(ndr, "result", r->out.result);
23063                 ndr->depth--;
23064         }
23065         ndr->depth--;
23066 }
23067
23068 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23069 {
23070         if (flags & NDR_IN) {
23071         }
23072         if (flags & NDR_OUT) {
23073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23074         }
23075         return NDR_ERR_SUCCESS;
23076 }
23077
23078 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23079 {
23080         if (flags & NDR_IN) {
23081         }
23082         if (flags & NDR_OUT) {
23083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23084         }
23085         return NDR_ERR_SUCCESS;
23086 }
23087
23088 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23089 {
23090         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23091         ndr->depth++;
23092         if (flags & NDR_SET_VALUES) {
23093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23094         }
23095         if (flags & NDR_IN) {
23096                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23097                 ndr->depth++;
23098                 ndr->depth--;
23099         }
23100         if (flags & NDR_OUT) {
23101                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23102                 ndr->depth++;
23103                 ndr_print_WERROR(ndr, "result", r->out.result);
23104                 ndr->depth--;
23105         }
23106         ndr->depth--;
23107 }
23108
23109 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23110 {
23111         if (flags & NDR_IN) {
23112         }
23113         if (flags & NDR_OUT) {
23114                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23115         }
23116         return NDR_ERR_SUCCESS;
23117 }
23118
23119 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23120 {
23121         if (flags & NDR_IN) {
23122         }
23123         if (flags & NDR_OUT) {
23124                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23125         }
23126         return NDR_ERR_SUCCESS;
23127 }
23128
23129 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23130 {
23131         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23132         ndr->depth++;
23133         if (flags & NDR_SET_VALUES) {
23134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23135         }
23136         if (flags & NDR_IN) {
23137                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23138                 ndr->depth++;
23139                 ndr->depth--;
23140         }
23141         if (flags & NDR_OUT) {
23142                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23143                 ndr->depth++;
23144                 ndr_print_WERROR(ndr, "result", r->out.result);
23145                 ndr->depth--;
23146         }
23147         ndr->depth--;
23148 }
23149
23150 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23151 {
23152         if (flags & NDR_IN) {
23153         }
23154         if (flags & NDR_OUT) {
23155                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23156         }
23157         return NDR_ERR_SUCCESS;
23158 }
23159
23160 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23161 {
23162         if (flags & NDR_IN) {
23163         }
23164         if (flags & NDR_OUT) {
23165                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23166         }
23167         return NDR_ERR_SUCCESS;
23168 }
23169
23170 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23171 {
23172         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23173         ndr->depth++;
23174         if (flags & NDR_SET_VALUES) {
23175                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23176         }
23177         if (flags & NDR_IN) {
23178                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23179                 ndr->depth++;
23180                 ndr->depth--;
23181         }
23182         if (flags & NDR_OUT) {
23183                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23184                 ndr->depth++;
23185                 ndr_print_WERROR(ndr, "result", r->out.result);
23186                 ndr->depth--;
23187         }
23188         ndr->depth--;
23189 }
23190
23191 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23192 {
23193         if (flags & NDR_IN) {
23194         }
23195         if (flags & NDR_OUT) {
23196                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23197         }
23198         return NDR_ERR_SUCCESS;
23199 }
23200
23201 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23202 {
23203         if (flags & NDR_IN) {
23204         }
23205         if (flags & NDR_OUT) {
23206                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23207         }
23208         return NDR_ERR_SUCCESS;
23209 }
23210
23211 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23212 {
23213         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23214         ndr->depth++;
23215         if (flags & NDR_SET_VALUES) {
23216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23217         }
23218         if (flags & NDR_IN) {
23219                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23220                 ndr->depth++;
23221                 ndr->depth--;
23222         }
23223         if (flags & NDR_OUT) {
23224                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23225                 ndr->depth++;
23226                 ndr_print_WERROR(ndr, "result", r->out.result);
23227                 ndr->depth--;
23228         }
23229         ndr->depth--;
23230 }
23231
23232 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23233 {
23234         if (flags & NDR_IN) {
23235         }
23236         if (flags & NDR_OUT) {
23237                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23238         }
23239         return NDR_ERR_SUCCESS;
23240 }
23241
23242 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23243 {
23244         if (flags & NDR_IN) {
23245         }
23246         if (flags & NDR_OUT) {
23247                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23248         }
23249         return NDR_ERR_SUCCESS;
23250 }
23251
23252 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23253 {
23254         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23255         ndr->depth++;
23256         if (flags & NDR_SET_VALUES) {
23257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23258         }
23259         if (flags & NDR_IN) {
23260                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23261                 ndr->depth++;
23262                 ndr->depth--;
23263         }
23264         if (flags & NDR_OUT) {
23265                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23266                 ndr->depth++;
23267                 ndr_print_WERROR(ndr, "result", r->out.result);
23268                 ndr->depth--;
23269         }
23270         ndr->depth--;
23271 }
23272
23273 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23274 {
23275         if (flags & NDR_IN) {
23276         }
23277         if (flags & NDR_OUT) {
23278                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23279         }
23280         return NDR_ERR_SUCCESS;
23281 }
23282
23283 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23284 {
23285         if (flags & NDR_IN) {
23286         }
23287         if (flags & NDR_OUT) {
23288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23289         }
23290         return NDR_ERR_SUCCESS;
23291 }
23292
23293 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23294 {
23295         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23296         ndr->depth++;
23297         if (flags & NDR_SET_VALUES) {
23298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23299         }
23300         if (flags & NDR_IN) {
23301                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23302                 ndr->depth++;
23303                 ndr->depth--;
23304         }
23305         if (flags & NDR_OUT) {
23306                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23307                 ndr->depth++;
23308                 ndr_print_WERROR(ndr, "result", r->out.result);
23309                 ndr->depth--;
23310         }
23311         ndr->depth--;
23312 }
23313
23314 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23315 {
23316         if (flags & NDR_IN) {
23317         }
23318         if (flags & NDR_OUT) {
23319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23320         }
23321         return NDR_ERR_SUCCESS;
23322 }
23323
23324 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23325 {
23326         if (flags & NDR_IN) {
23327         }
23328         if (flags & NDR_OUT) {
23329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23330         }
23331         return NDR_ERR_SUCCESS;
23332 }
23333
23334 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23335 {
23336         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23337         ndr->depth++;
23338         if (flags & NDR_SET_VALUES) {
23339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23340         }
23341         if (flags & NDR_IN) {
23342                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23343                 ndr->depth++;
23344                 ndr->depth--;
23345         }
23346         if (flags & NDR_OUT) {
23347                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23348                 ndr->depth++;
23349                 ndr_print_WERROR(ndr, "result", r->out.result);
23350                 ndr->depth--;
23351         }
23352         ndr->depth--;
23353 }
23354
23355 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23356 {
23357         if (flags & NDR_IN) {
23358         }
23359         if (flags & NDR_OUT) {
23360                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23361         }
23362         return NDR_ERR_SUCCESS;
23363 }
23364
23365 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23366 {
23367         if (flags & NDR_IN) {
23368         }
23369         if (flags & NDR_OUT) {
23370                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23371         }
23372         return NDR_ERR_SUCCESS;
23373 }
23374
23375 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23376 {
23377         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23378         ndr->depth++;
23379         if (flags & NDR_SET_VALUES) {
23380                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23381         }
23382         if (flags & NDR_IN) {
23383                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23384                 ndr->depth++;
23385                 ndr->depth--;
23386         }
23387         if (flags & NDR_OUT) {
23388                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23389                 ndr->depth++;
23390                 ndr_print_WERROR(ndr, "result", r->out.result);
23391                 ndr->depth--;
23392         }
23393         ndr->depth--;
23394 }
23395
23396 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23397 {
23398         if (flags & NDR_IN) {
23399         }
23400         if (flags & NDR_OUT) {
23401                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23402         }
23403         return NDR_ERR_SUCCESS;
23404 }
23405
23406 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23407 {
23408         if (flags & NDR_IN) {
23409         }
23410         if (flags & NDR_OUT) {
23411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23412         }
23413         return NDR_ERR_SUCCESS;
23414 }
23415
23416 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23417 {
23418         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23419         ndr->depth++;
23420         if (flags & NDR_SET_VALUES) {
23421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23422         }
23423         if (flags & NDR_IN) {
23424                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23425                 ndr->depth++;
23426                 ndr->depth--;
23427         }
23428         if (flags & NDR_OUT) {
23429                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23430                 ndr->depth++;
23431                 ndr_print_WERROR(ndr, "result", r->out.result);
23432                 ndr->depth--;
23433         }
23434         ndr->depth--;
23435 }
23436
23437 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23438 {
23439         if (flags & NDR_IN) {
23440         }
23441         if (flags & NDR_OUT) {
23442                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23443         }
23444         return NDR_ERR_SUCCESS;
23445 }
23446
23447 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23448 {
23449         if (flags & NDR_IN) {
23450         }
23451         if (flags & NDR_OUT) {
23452                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23453         }
23454         return NDR_ERR_SUCCESS;
23455 }
23456
23457 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23458 {
23459         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23460         ndr->depth++;
23461         if (flags & NDR_SET_VALUES) {
23462                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23463         }
23464         if (flags & NDR_IN) {
23465                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23466                 ndr->depth++;
23467                 ndr->depth--;
23468         }
23469         if (flags & NDR_OUT) {
23470                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23471                 ndr->depth++;
23472                 ndr_print_WERROR(ndr, "result", r->out.result);
23473                 ndr->depth--;
23474         }
23475         ndr->depth--;
23476 }
23477
23478 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23479 {
23480         if (flags & NDR_IN) {
23481         }
23482         if (flags & NDR_OUT) {
23483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23484         }
23485         return NDR_ERR_SUCCESS;
23486 }
23487
23488 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23489 {
23490         if (flags & NDR_IN) {
23491         }
23492         if (flags & NDR_OUT) {
23493                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23494         }
23495         return NDR_ERR_SUCCESS;
23496 }
23497
23498 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23499 {
23500         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23501         ndr->depth++;
23502         if (flags & NDR_SET_VALUES) {
23503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23504         }
23505         if (flags & NDR_IN) {
23506                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23507                 ndr->depth++;
23508                 ndr->depth--;
23509         }
23510         if (flags & NDR_OUT) {
23511                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23512                 ndr->depth++;
23513                 ndr_print_WERROR(ndr, "result", r->out.result);
23514                 ndr->depth--;
23515         }
23516         ndr->depth--;
23517 }
23518
23519 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23520 {
23521         if (flags & NDR_IN) {
23522         }
23523         if (flags & NDR_OUT) {
23524                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23525         }
23526         return NDR_ERR_SUCCESS;
23527 }
23528
23529 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23530 {
23531         if (flags & NDR_IN) {
23532         }
23533         if (flags & NDR_OUT) {
23534                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23535         }
23536         return NDR_ERR_SUCCESS;
23537 }
23538
23539 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23540 {
23541         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23542         ndr->depth++;
23543         if (flags & NDR_SET_VALUES) {
23544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23545         }
23546         if (flags & NDR_IN) {
23547                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23548                 ndr->depth++;
23549                 ndr->depth--;
23550         }
23551         if (flags & NDR_OUT) {
23552                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23553                 ndr->depth++;
23554                 ndr_print_WERROR(ndr, "result", r->out.result);
23555                 ndr->depth--;
23556         }
23557         ndr->depth--;
23558 }
23559
23560 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23561 {
23562         if (flags & NDR_IN) {
23563         }
23564         if (flags & NDR_OUT) {
23565                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23566         }
23567         return NDR_ERR_SUCCESS;
23568 }
23569
23570 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23571 {
23572         if (flags & NDR_IN) {
23573         }
23574         if (flags & NDR_OUT) {
23575                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23576         }
23577         return NDR_ERR_SUCCESS;
23578 }
23579
23580 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23581 {
23582         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23583         ndr->depth++;
23584         if (flags & NDR_SET_VALUES) {
23585                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23586         }
23587         if (flags & NDR_IN) {
23588                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23589                 ndr->depth++;
23590                 ndr->depth--;
23591         }
23592         if (flags & NDR_OUT) {
23593                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23594                 ndr->depth++;
23595                 ndr_print_WERROR(ndr, "result", r->out.result);
23596                 ndr->depth--;
23597         }
23598         ndr->depth--;
23599 }
23600
23601 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23602 {
23603         if (flags & NDR_IN) {
23604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23605                 if (r->in.servername) {
23606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23610                 }
23611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23612                 if (r->in.print_processor_name) {
23613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23616                         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));
23617                 }
23618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23620                 if (r->in.buffer) {
23621                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23622                 }
23623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23624         }
23625         if (flags & NDR_OUT) {
23626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23627                 if (r->out.info) {
23628                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23629                 }
23630                 if (r->out.needed == NULL) {
23631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23632                 }
23633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23634                 if (r->out.count == NULL) {
23635                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23636                 }
23637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23638                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23639         }
23640         return NDR_ERR_SUCCESS;
23641 }
23642
23643 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23644 {
23645         uint32_t _ptr_servername;
23646         uint32_t _ptr_print_processor_name;
23647         uint32_t _ptr_buffer;
23648         uint32_t _ptr_info;
23649         TALLOC_CTX *_mem_save_servername_0;
23650         TALLOC_CTX *_mem_save_print_processor_name_0;
23651         TALLOC_CTX *_mem_save_buffer_0;
23652         TALLOC_CTX *_mem_save_info_0;
23653         TALLOC_CTX *_mem_save_needed_0;
23654         TALLOC_CTX *_mem_save_count_0;
23655         if (flags & NDR_IN) {
23656                 ZERO_STRUCT(r->out);
23657
23658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23659                 if (_ptr_servername) {
23660                         NDR_PULL_ALLOC(ndr, r->in.servername);
23661                 } else {
23662                         r->in.servername = NULL;
23663                 }
23664                 if (r->in.servername) {
23665                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23666                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23667                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23668                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23669                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23670                                 return 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));
23671                         }
23672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23675                 }
23676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23677                 if (_ptr_print_processor_name) {
23678                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23679                 } else {
23680                         r->in.print_processor_name = NULL;
23681                 }
23682                 if (r->in.print_processor_name) {
23683                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23684                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23685                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23686                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23687                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23688                                 return 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));
23689                         }
23690                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23691                         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));
23692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23693                 }
23694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23696                 if (_ptr_buffer) {
23697                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23698                 } else {
23699                         r->in.buffer = NULL;
23700                 }
23701                 if (r->in.buffer) {
23702                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23703                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23704                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23706                 }
23707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23708                 NDR_PULL_ALLOC(ndr, r->out.needed);
23709                 ZERO_STRUCTP(r->out.needed);
23710                 NDR_PULL_ALLOC(ndr, r->out.count);
23711                 ZERO_STRUCTP(r->out.count);
23712         }
23713         if (flags & NDR_OUT) {
23714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23715                 if (_ptr_info) {
23716                         NDR_PULL_ALLOC(ndr, r->out.info);
23717                 } else {
23718                         r->out.info = NULL;
23719                 }
23720                 if (r->out.info) {
23721                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23722                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23723                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23725                 }
23726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23727                         NDR_PULL_ALLOC(ndr, r->out.needed);
23728                 }
23729                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23730                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23734                         NDR_PULL_ALLOC(ndr, r->out.count);
23735                 }
23736                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23737                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23740                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23741         }
23742         return NDR_ERR_SUCCESS;
23743 }
23744
23745 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23746 {
23747         uint32_t cntr_info_0;
23748         if (flags & NDR_IN) {
23749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23751         }
23752         if (flags & NDR_OUT) {
23753                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23754                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23755                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23756                 }
23757                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23758                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23759                 }
23760         }
23761         return NDR_ERR_SUCCESS;
23762 }
23763
23764 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23765 {
23766         uint32_t cntr_info_0;
23767         TALLOC_CTX *_mem_save_info_0;
23768         if (flags & NDR_IN) {
23769                 ZERO_STRUCT(r->out);
23770
23771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23773         }
23774         if (flags & NDR_OUT) {
23775                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23776                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23777                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23778                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23779                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23780                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23781                 }
23782                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23783                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23784                 }
23785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23786         }
23787         return NDR_ERR_SUCCESS;
23788 }
23789
23790 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23791 {
23792         uint32_t cntr_info_2;
23793         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23794         ndr->depth++;
23795         if (flags & NDR_SET_VALUES) {
23796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23797         }
23798         if (flags & NDR_IN) {
23799                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23800                 ndr->depth++;
23801                 ndr_print_ptr(ndr, "servername", r->in.servername);
23802                 ndr->depth++;
23803                 if (r->in.servername) {
23804                         ndr_print_string(ndr, "servername", r->in.servername);
23805                 }
23806                 ndr->depth--;
23807                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23808                 ndr->depth++;
23809                 if (r->in.print_processor_name) {
23810                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23811                 }
23812                 ndr->depth--;
23813                 ndr_print_uint32(ndr, "level", r->in.level);
23814                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23815                 ndr->depth++;
23816                 if (r->in.buffer) {
23817                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23818                 }
23819                 ndr->depth--;
23820                 ndr_print_uint32(ndr, "offered", r->in.offered);
23821                 ndr->depth--;
23822         }
23823         if (flags & NDR_OUT) {
23824                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23825                 ndr->depth++;
23826                 ndr_print_ptr(ndr, "count", r->out.count);
23827                 ndr->depth++;
23828                 ndr_print_uint32(ndr, "count", *r->out.count);
23829                 ndr->depth--;
23830                 ndr_print_ptr(ndr, "info", r->out.info);
23831                 ndr->depth++;
23832                 ndr_print_ptr(ndr, "info", *r->out.info);
23833                 ndr->depth++;
23834                 if (*r->out.info) {
23835                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23836                         ndr->depth++;
23837                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23838                                 char *idx_2=NULL;
23839                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23840                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23841                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23842                                         free(idx_2);
23843                                 }
23844                         }
23845                         ndr->depth--;
23846                 }
23847                 ndr->depth--;
23848                 ndr->depth--;
23849                 ndr_print_ptr(ndr, "needed", r->out.needed);
23850                 ndr->depth++;
23851                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23852                 ndr->depth--;
23853                 ndr_print_WERROR(ndr, "result", r->out.result);
23854                 ndr->depth--;
23855         }
23856         ndr->depth--;
23857 }
23858
23859 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23860 {
23861         if (flags & NDR_IN) {
23862                 if (r->in.handle == NULL) {
23863                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23864                 }
23865                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23867                 if (r->in.data_type) {
23868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23871                         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));
23872                 }
23873                 if (r->in.devmode_ctr == NULL) {
23874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23875                 }
23876                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23877         }
23878         if (flags & NDR_OUT) {
23879                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23880         }
23881         return NDR_ERR_SUCCESS;
23882 }
23883
23884 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23885 {
23886         uint32_t _ptr_data_type;
23887         TALLOC_CTX *_mem_save_handle_0;
23888         TALLOC_CTX *_mem_save_data_type_0;
23889         TALLOC_CTX *_mem_save_devmode_ctr_0;
23890         if (flags & NDR_IN) {
23891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23892                         NDR_PULL_ALLOC(ndr, r->in.handle);
23893                 }
23894                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23895                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23896                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23899                 if (_ptr_data_type) {
23900                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23901                 } else {
23902                         r->in.data_type = NULL;
23903                 }
23904                 if (r->in.data_type) {
23905                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23906                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23908                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23909                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23910                                 return 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));
23911                         }
23912                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23913                         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));
23914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23915                 }
23916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23917                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23918                 }
23919                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23920                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23921                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23923         }
23924         if (flags & NDR_OUT) {
23925                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23926         }
23927         return NDR_ERR_SUCCESS;
23928 }
23929
23930 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23931 {
23932         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23933         ndr->depth++;
23934         if (flags & NDR_SET_VALUES) {
23935                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23936         }
23937         if (flags & NDR_IN) {
23938                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23939                 ndr->depth++;
23940                 ndr_print_ptr(ndr, "handle", r->in.handle);
23941                 ndr->depth++;
23942                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23943                 ndr->depth--;
23944                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23945                 ndr->depth++;
23946                 if (r->in.data_type) {
23947                         ndr_print_string(ndr, "data_type", r->in.data_type);
23948                 }
23949                 ndr->depth--;
23950                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23951                 ndr->depth++;
23952                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23953                 ndr->depth--;
23954                 ndr->depth--;
23955         }
23956         if (flags & NDR_OUT) {
23957                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23958                 ndr->depth++;
23959                 ndr_print_WERROR(ndr, "result", r->out.result);
23960                 ndr->depth--;
23961         }
23962         ndr->depth--;
23963 }
23964
23965 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23966 {
23967         if (flags & NDR_IN) {
23968                 if (r->in.handle == NULL) {
23969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23970                 }
23971                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23973                 if (r->in.architecture) {
23974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23977                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23978                 }
23979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23981                 if (r->in.buffer) {
23982                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23983                 }
23984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23987         }
23988         if (flags & NDR_OUT) {
23989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23990                 if (r->out.info) {
23991                         {
23992                                 struct ndr_push *_ndr_info;
23993                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23994                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23995                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23996                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23997                         }
23998                 }
23999                 if (r->out.needed == NULL) {
24000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24001                 }
24002                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24003                 if (r->out.server_major_version == NULL) {
24004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24005                 }
24006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24007                 if (r->out.server_minor_version == NULL) {
24008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24009                 }
24010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24011                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24012         }
24013         return NDR_ERR_SUCCESS;
24014 }
24015
24016 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24017 {
24018         uint32_t _ptr_architecture;
24019         uint32_t _ptr_buffer;
24020         uint32_t _ptr_info;
24021         TALLOC_CTX *_mem_save_handle_0;
24022         TALLOC_CTX *_mem_save_architecture_0;
24023         TALLOC_CTX *_mem_save_buffer_0;
24024         TALLOC_CTX *_mem_save_info_0;
24025         TALLOC_CTX *_mem_save_needed_0;
24026         TALLOC_CTX *_mem_save_server_major_version_0;
24027         TALLOC_CTX *_mem_save_server_minor_version_0;
24028         if (flags & NDR_IN) {
24029                 ZERO_STRUCT(r->out);
24030
24031                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24032                         NDR_PULL_ALLOC(ndr, r->in.handle);
24033                 }
24034                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24035                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24036                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24037                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24039                 if (_ptr_architecture) {
24040                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24041                 } else {
24042                         r->in.architecture = NULL;
24043                 }
24044                 if (r->in.architecture) {
24045                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24046                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24048                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24049                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24050                                 return 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));
24051                         }
24052                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24053                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24055                 }
24056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24058                 if (_ptr_buffer) {
24059                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24060                 } else {
24061                         r->in.buffer = NULL;
24062                 }
24063                 if (r->in.buffer) {
24064                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24065                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24066                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24068                 }
24069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24072                 NDR_PULL_ALLOC(ndr, r->out.needed);
24073                 ZERO_STRUCTP(r->out.needed);
24074                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24075                 ZERO_STRUCTP(r->out.server_major_version);
24076                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24077                 ZERO_STRUCTP(r->out.server_minor_version);
24078         }
24079         if (flags & NDR_OUT) {
24080                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24081                 if (_ptr_info) {
24082                         NDR_PULL_ALLOC(ndr, r->out.info);
24083                 } else {
24084                         r->out.info = NULL;
24085                 }
24086                 if (r->out.info) {
24087                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24088                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24089                         {
24090                                 struct ndr_pull *_ndr_info;
24091                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24092                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24093                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24094                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24095                         }
24096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24097                 }
24098                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24099                         NDR_PULL_ALLOC(ndr, r->out.needed);
24100                 }
24101                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24102                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24106                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24107                 }
24108                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24109                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24112                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24113                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24114                 }
24115                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24116                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24118                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24119                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24120         }
24121         return NDR_ERR_SUCCESS;
24122 }
24123
24124 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24125 {
24126         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24127         ndr->depth++;
24128         if (flags & NDR_SET_VALUES) {
24129                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24130         }
24131         if (flags & NDR_IN) {
24132                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24133                 ndr->depth++;
24134                 ndr_print_ptr(ndr, "handle", r->in.handle);
24135                 ndr->depth++;
24136                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24137                 ndr->depth--;
24138                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24139                 ndr->depth++;
24140                 if (r->in.architecture) {
24141                         ndr_print_string(ndr, "architecture", r->in.architecture);
24142                 }
24143                 ndr->depth--;
24144                 ndr_print_uint32(ndr, "level", r->in.level);
24145                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24146                 ndr->depth++;
24147                 if (r->in.buffer) {
24148                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24149                 }
24150                 ndr->depth--;
24151                 ndr_print_uint32(ndr, "offered", r->in.offered);
24152                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24153                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24154                 ndr->depth--;
24155         }
24156         if (flags & NDR_OUT) {
24157                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24158                 ndr->depth++;
24159                 ndr_print_ptr(ndr, "info", r->out.info);
24160                 ndr->depth++;
24161                 if (r->out.info) {
24162                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24163                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24164                 }
24165                 ndr->depth--;
24166                 ndr_print_ptr(ndr, "needed", r->out.needed);
24167                 ndr->depth++;
24168                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24169                 ndr->depth--;
24170                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24171                 ndr->depth++;
24172                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24173                 ndr->depth--;
24174                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24175                 ndr->depth++;
24176                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24177                 ndr->depth--;
24178                 ndr_print_WERROR(ndr, "result", r->out.result);
24179                 ndr->depth--;
24180         }
24181         ndr->depth--;
24182 }
24183
24184 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24185 {
24186         if (flags & NDR_IN) {
24187         }
24188         if (flags & NDR_OUT) {
24189                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24190         }
24191         return NDR_ERR_SUCCESS;
24192 }
24193
24194 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24195 {
24196         if (flags & NDR_IN) {
24197         }
24198         if (flags & NDR_OUT) {
24199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24200         }
24201         return NDR_ERR_SUCCESS;
24202 }
24203
24204 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24205 {
24206         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24207         ndr->depth++;
24208         if (flags & NDR_SET_VALUES) {
24209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24210         }
24211         if (flags & NDR_IN) {
24212                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24213                 ndr->depth++;
24214                 ndr->depth--;
24215         }
24216         if (flags & NDR_OUT) {
24217                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24218                 ndr->depth++;
24219                 ndr_print_WERROR(ndr, "result", r->out.result);
24220                 ndr->depth--;
24221         }
24222         ndr->depth--;
24223 }
24224
24225 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24226 {
24227         if (flags & NDR_IN) {
24228         }
24229         if (flags & NDR_OUT) {
24230                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24231         }
24232         return NDR_ERR_SUCCESS;
24233 }
24234
24235 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24236 {
24237         if (flags & NDR_IN) {
24238         }
24239         if (flags & NDR_OUT) {
24240                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24241         }
24242         return NDR_ERR_SUCCESS;
24243 }
24244
24245 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24246 {
24247         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24248         ndr->depth++;
24249         if (flags & NDR_SET_VALUES) {
24250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24251         }
24252         if (flags & NDR_IN) {
24253                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24254                 ndr->depth++;
24255                 ndr->depth--;
24256         }
24257         if (flags & NDR_OUT) {
24258                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24259                 ndr->depth++;
24260                 ndr_print_WERROR(ndr, "result", r->out.result);
24261                 ndr->depth--;
24262         }
24263         ndr->depth--;
24264 }
24265
24266 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24267 {
24268         if (flags & NDR_IN) {
24269                 if (r->in.handle == NULL) {
24270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24271                 }
24272                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24273         }
24274         if (flags & NDR_OUT) {
24275                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24276         }
24277         return NDR_ERR_SUCCESS;
24278 }
24279
24280 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24281 {
24282         TALLOC_CTX *_mem_save_handle_0;
24283         if (flags & NDR_IN) {
24284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24285                         NDR_PULL_ALLOC(ndr, r->in.handle);
24286                 }
24287                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24288                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24289                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24291         }
24292         if (flags & NDR_OUT) {
24293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24294         }
24295         return NDR_ERR_SUCCESS;
24296 }
24297
24298 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24299 {
24300         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24301         ndr->depth++;
24302         if (flags & NDR_SET_VALUES) {
24303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24304         }
24305         if (flags & NDR_IN) {
24306                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24307                 ndr->depth++;
24308                 ndr_print_ptr(ndr, "handle", r->in.handle);
24309                 ndr->depth++;
24310                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24311                 ndr->depth--;
24312                 ndr->depth--;
24313         }
24314         if (flags & NDR_OUT) {
24315                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24316                 ndr->depth++;
24317                 ndr_print_WERROR(ndr, "result", r->out.result);
24318                 ndr->depth--;
24319         }
24320         ndr->depth--;
24321 }
24322
24323 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24324 {
24325         if (flags & NDR_IN) {
24326         }
24327         if (flags & NDR_OUT) {
24328                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24329         }
24330         return NDR_ERR_SUCCESS;
24331 }
24332
24333 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24334 {
24335         if (flags & NDR_IN) {
24336         }
24337         if (flags & NDR_OUT) {
24338                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24339         }
24340         return NDR_ERR_SUCCESS;
24341 }
24342
24343 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24344 {
24345         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24346         ndr->depth++;
24347         if (flags & NDR_SET_VALUES) {
24348                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24349         }
24350         if (flags & NDR_IN) {
24351                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24352                 ndr->depth++;
24353                 ndr->depth--;
24354         }
24355         if (flags & NDR_OUT) {
24356                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24357                 ndr->depth++;
24358                 ndr_print_WERROR(ndr, "result", r->out.result);
24359                 ndr->depth--;
24360         }
24361         ndr->depth--;
24362 }
24363
24364 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24365 {
24366         if (flags & NDR_IN) {
24367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24370                 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));
24371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24372                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24375                 if (r->in.buffer) {
24376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24377                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24378                 }
24379         }
24380         if (flags & NDR_OUT) {
24381                 if (r->out.handle == NULL) {
24382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24383                 }
24384                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24385                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24386         }
24387         return NDR_ERR_SUCCESS;
24388 }
24389
24390 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24391 {
24392         uint32_t _ptr_buffer;
24393         TALLOC_CTX *_mem_save_buffer_0;
24394         TALLOC_CTX *_mem_save_handle_0;
24395         if (flags & NDR_IN) {
24396                 ZERO_STRUCT(r->out);
24397
24398                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24399                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24400                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24401                         return 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));
24402                 }
24403                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24404                 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));
24405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24406                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24408                 if (r->in.bufsize > 512) {
24409                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24410                 }
24411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24412                 if (_ptr_buffer) {
24413                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24414                 } else {
24415                         r->in.buffer = NULL;
24416                 }
24417                 if (r->in.buffer) {
24418                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24419                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24421                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24422                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24424                 }
24425                 NDR_PULL_ALLOC(ndr, r->out.handle);
24426                 ZERO_STRUCTP(r->out.handle);
24427                 if (r->in.buffer) {
24428                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24429                 }
24430         }
24431         if (flags & NDR_OUT) {
24432                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24433                         NDR_PULL_ALLOC(ndr, r->out.handle);
24434                 }
24435                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24436                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24437                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24439                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24440         }
24441         return NDR_ERR_SUCCESS;
24442 }
24443
24444 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24445 {
24446         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24447         ndr->depth++;
24448         if (flags & NDR_SET_VALUES) {
24449                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24450         }
24451         if (flags & NDR_IN) {
24452                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24453                 ndr->depth++;
24454                 ndr_print_string(ndr, "server_name", r->in.server_name);
24455                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24456                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24457                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24458                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24459                 ndr->depth++;
24460                 if (r->in.buffer) {
24461                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24462                 }
24463                 ndr->depth--;
24464                 ndr->depth--;
24465         }
24466         if (flags & NDR_OUT) {
24467                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24468                 ndr->depth++;
24469                 ndr_print_ptr(ndr, "handle", r->out.handle);
24470                 ndr->depth++;
24471                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24472                 ndr->depth--;
24473                 ndr_print_WERROR(ndr, "result", r->out.result);
24474                 ndr->depth--;
24475         }
24476         ndr->depth--;
24477 }
24478
24479 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24480 {
24481         if (flags & NDR_IN) {
24482                 if (r->in.handle == NULL) {
24483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24484                 }
24485                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24486                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24488                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24489                 if (r->in.buffer) {
24490                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24491                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24492                 }
24493         }
24494         if (flags & NDR_OUT) {
24495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24496         }
24497         return NDR_ERR_SUCCESS;
24498 }
24499
24500 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24501 {
24502         uint32_t _ptr_buffer;
24503         TALLOC_CTX *_mem_save_handle_0;
24504         TALLOC_CTX *_mem_save_buffer_0;
24505         if (flags & NDR_IN) {
24506                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24507                         NDR_PULL_ALLOC(ndr, r->in.handle);
24508                 }
24509                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24510                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24511                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24513                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24515                 if (r->in.bufsize > 512) {
24516                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24517                 }
24518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24519                 if (_ptr_buffer) {
24520                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24521                 } else {
24522                         r->in.buffer = NULL;
24523                 }
24524                 if (r->in.buffer) {
24525                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24526                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24528                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24529                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24531                 }
24532                 if (r->in.buffer) {
24533                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24534                 }
24535         }
24536         if (flags & NDR_OUT) {
24537                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24538         }
24539         return NDR_ERR_SUCCESS;
24540 }
24541
24542 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24543 {
24544         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24545         ndr->depth++;
24546         if (flags & NDR_SET_VALUES) {
24547                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24548         }
24549         if (flags & NDR_IN) {
24550                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24551                 ndr->depth++;
24552                 ndr_print_ptr(ndr, "handle", r->in.handle);
24553                 ndr->depth++;
24554                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24555                 ndr->depth--;
24556                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24557                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24558                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24559                 ndr->depth++;
24560                 if (r->in.buffer) {
24561                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24562                 }
24563                 ndr->depth--;
24564                 ndr->depth--;
24565         }
24566         if (flags & NDR_OUT) {
24567                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24568                 ndr->depth++;
24569                 ndr_print_WERROR(ndr, "result", r->out.result);
24570                 ndr->depth--;
24571         }
24572         ndr->depth--;
24573 }
24574
24575 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24576 {
24577         if (flags & NDR_IN) {
24578                 if (r->in.handle == NULL) {
24579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24580                 }
24581                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24582         }
24583         if (flags & NDR_OUT) {
24584                 if (r->out.handle == NULL) {
24585                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24586                 }
24587                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24588                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24589         }
24590         return NDR_ERR_SUCCESS;
24591 }
24592
24593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24594 {
24595         TALLOC_CTX *_mem_save_handle_0;
24596         if (flags & NDR_IN) {
24597                 ZERO_STRUCT(r->out);
24598
24599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24600                         NDR_PULL_ALLOC(ndr, r->in.handle);
24601                 }
24602                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24603                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24604                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24606                 NDR_PULL_ALLOC(ndr, r->out.handle);
24607                 *r->out.handle = *r->in.handle;
24608         }
24609         if (flags & NDR_OUT) {
24610                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24611                         NDR_PULL_ALLOC(ndr, r->out.handle);
24612                 }
24613                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24614                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24615                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24617                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24618         }
24619         return NDR_ERR_SUCCESS;
24620 }
24621
24622 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24623 {
24624         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24625         ndr->depth++;
24626         if (flags & NDR_SET_VALUES) {
24627                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24628         }
24629         if (flags & NDR_IN) {
24630                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24631                 ndr->depth++;
24632                 ndr_print_ptr(ndr, "handle", r->in.handle);
24633                 ndr->depth++;
24634                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24635                 ndr->depth--;
24636                 ndr->depth--;
24637         }
24638         if (flags & NDR_OUT) {
24639                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24640                 ndr->depth++;
24641                 ndr_print_ptr(ndr, "handle", r->out.handle);
24642                 ndr->depth++;
24643                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24644                 ndr->depth--;
24645                 ndr_print_WERROR(ndr, "result", r->out.result);
24646                 ndr->depth--;
24647         }
24648         ndr->depth--;
24649 }
24650
24651 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24652 {
24653         if (flags & NDR_IN) {
24654         }
24655         if (flags & NDR_OUT) {
24656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24657         }
24658         return NDR_ERR_SUCCESS;
24659 }
24660
24661 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24662 {
24663         if (flags & NDR_IN) {
24664         }
24665         if (flags & NDR_OUT) {
24666                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24667         }
24668         return NDR_ERR_SUCCESS;
24669 }
24670
24671 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24672 {
24673         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24674         ndr->depth++;
24675         if (flags & NDR_SET_VALUES) {
24676                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24677         }
24678         if (flags & NDR_IN) {
24679                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24680                 ndr->depth++;
24681                 ndr->depth--;
24682         }
24683         if (flags & NDR_OUT) {
24684                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24685                 ndr->depth++;
24686                 ndr_print_WERROR(ndr, "result", r->out.result);
24687                 ndr->depth--;
24688         }
24689         ndr->depth--;
24690 }
24691
24692 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24693 {
24694         if (flags & NDR_IN) {
24695         }
24696         if (flags & NDR_OUT) {
24697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24698         }
24699         return NDR_ERR_SUCCESS;
24700 }
24701
24702 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24703 {
24704         if (flags & NDR_IN) {
24705         }
24706         if (flags & NDR_OUT) {
24707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24708         }
24709         return NDR_ERR_SUCCESS;
24710 }
24711
24712 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24713 {
24714         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24715         ndr->depth++;
24716         if (flags & NDR_SET_VALUES) {
24717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24718         }
24719         if (flags & NDR_IN) {
24720                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24721                 ndr->depth++;
24722                 ndr->depth--;
24723         }
24724         if (flags & NDR_OUT) {
24725                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24726                 ndr->depth++;
24727                 ndr_print_WERROR(ndr, "result", r->out.result);
24728                 ndr->depth--;
24729         }
24730         ndr->depth--;
24731 }
24732
24733 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24734 {
24735         if (flags & NDR_IN) {
24736         }
24737         if (flags & NDR_OUT) {
24738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24739         }
24740         return NDR_ERR_SUCCESS;
24741 }
24742
24743 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24744 {
24745         if (flags & NDR_IN) {
24746         }
24747         if (flags & NDR_OUT) {
24748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24749         }
24750         return NDR_ERR_SUCCESS;
24751 }
24752
24753 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24754 {
24755         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24756         ndr->depth++;
24757         if (flags & NDR_SET_VALUES) {
24758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24759         }
24760         if (flags & NDR_IN) {
24761                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24762                 ndr->depth++;
24763                 ndr->depth--;
24764         }
24765         if (flags & NDR_OUT) {
24766                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24767                 ndr->depth++;
24768                 ndr_print_WERROR(ndr, "result", r->out.result);
24769                 ndr->depth--;
24770         }
24771         ndr->depth--;
24772 }
24773
24774 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24775 {
24776         if (flags & NDR_IN) {
24777         }
24778         if (flags & NDR_OUT) {
24779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24780         }
24781         return NDR_ERR_SUCCESS;
24782 }
24783
24784 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24785 {
24786         if (flags & NDR_IN) {
24787         }
24788         if (flags & NDR_OUT) {
24789                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24790         }
24791         return NDR_ERR_SUCCESS;
24792 }
24793
24794 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24795 {
24796         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24797         ndr->depth++;
24798         if (flags & NDR_SET_VALUES) {
24799                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24800         }
24801         if (flags & NDR_IN) {
24802                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24803                 ndr->depth++;
24804                 ndr->depth--;
24805         }
24806         if (flags & NDR_OUT) {
24807                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24808                 ndr->depth++;
24809                 ndr_print_WERROR(ndr, "result", r->out.result);
24810                 ndr->depth--;
24811         }
24812         ndr->depth--;
24813 }
24814
24815 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24816 {
24817         if (flags & NDR_IN) {
24818                 if (r->in.handle == NULL) {
24819                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24820                 }
24821                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24822                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24824                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24825                 if (r->in.local_machine) {
24826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24829                         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));
24830                 }
24831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24833                 if (r->in.notify_options) {
24834                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24835                 }
24836         }
24837         if (flags & NDR_OUT) {
24838                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24839         }
24840         return NDR_ERR_SUCCESS;
24841 }
24842
24843 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24844 {
24845         uint32_t _ptr_local_machine;
24846         uint32_t _ptr_notify_options;
24847         TALLOC_CTX *_mem_save_handle_0;
24848         TALLOC_CTX *_mem_save_local_machine_0;
24849         TALLOC_CTX *_mem_save_notify_options_0;
24850         if (flags & NDR_IN) {
24851                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24852                         NDR_PULL_ALLOC(ndr, r->in.handle);
24853                 }
24854                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24855                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24856                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24857                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24858                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24861                 if (_ptr_local_machine) {
24862                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24863                 } else {
24864                         r->in.local_machine = NULL;
24865                 }
24866                 if (r->in.local_machine) {
24867                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24868                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24869                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24870                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24871                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24872                                 return 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));
24873                         }
24874                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24875                         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));
24876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24877                 }
24878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24880                 if (_ptr_notify_options) {
24881                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24882                 } else {
24883                         r->in.notify_options = NULL;
24884                 }
24885                 if (r->in.notify_options) {
24886                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24887                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24888                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24890                 }
24891         }
24892         if (flags & NDR_OUT) {
24893                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24894         }
24895         return NDR_ERR_SUCCESS;
24896 }
24897
24898 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24899 {
24900         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24901         ndr->depth++;
24902         if (flags & NDR_SET_VALUES) {
24903                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24904         }
24905         if (flags & NDR_IN) {
24906                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24907                 ndr->depth++;
24908                 ndr_print_ptr(ndr, "handle", r->in.handle);
24909                 ndr->depth++;
24910                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24911                 ndr->depth--;
24912                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24913                 ndr_print_uint32(ndr, "options", r->in.options);
24914                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24915                 ndr->depth++;
24916                 if (r->in.local_machine) {
24917                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24918                 }
24919                 ndr->depth--;
24920                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24921                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24922                 ndr->depth++;
24923                 if (r->in.notify_options) {
24924                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24925                 }
24926                 ndr->depth--;
24927                 ndr->depth--;
24928         }
24929         if (flags & NDR_OUT) {
24930                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24931                 ndr->depth++;
24932                 ndr_print_WERROR(ndr, "result", r->out.result);
24933                 ndr->depth--;
24934         }
24935         ndr->depth--;
24936 }
24937
24938 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24939 {
24940         if (flags & NDR_IN) {
24941                 if (r->in.handle == NULL) {
24942                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24943                 }
24944                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24946                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24948                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24949                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24950         }
24951         if (flags & NDR_OUT) {
24952                 if (r->out.reply_result == NULL) {
24953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24954                 }
24955                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24956                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24957         }
24958         return NDR_ERR_SUCCESS;
24959 }
24960
24961 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24962 {
24963         TALLOC_CTX *_mem_save_handle_0;
24964         TALLOC_CTX *_mem_save_reply_result_0;
24965         if (flags & NDR_IN) {
24966                 ZERO_STRUCT(r->out);
24967
24968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24969                         NDR_PULL_ALLOC(ndr, r->in.handle);
24970                 }
24971                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24972                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24973                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24976                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24978                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24979                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24980                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24981                 ZERO_STRUCTP(r->out.reply_result);
24982         }
24983         if (flags & NDR_OUT) {
24984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24985                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24986                 }
24987                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24988                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24989                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24992         }
24993         return NDR_ERR_SUCCESS;
24994 }
24995
24996 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24997 {
24998         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24999         ndr->depth++;
25000         if (flags & NDR_SET_VALUES) {
25001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25002         }
25003         if (flags & NDR_IN) {
25004                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25005                 ndr->depth++;
25006                 ndr_print_ptr(ndr, "handle", r->in.handle);
25007                 ndr->depth++;
25008                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25009                 ndr->depth--;
25010                 ndr_print_uint32(ndr, "color", r->in.color);
25011                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25012                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25013                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25014                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25015                 ndr->depth--;
25016         }
25017         if (flags & NDR_OUT) {
25018                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25019                 ndr->depth++;
25020                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25021                 ndr->depth++;
25022                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25023                 ndr->depth--;
25024                 ndr_print_WERROR(ndr, "result", r->out.result);
25025                 ndr->depth--;
25026         }
25027         ndr->depth--;
25028 }
25029
25030 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25031 {
25032         if (flags & NDR_IN) {
25033                 if (r->in.handle == NULL) {
25034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25035                 }
25036                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25039                 if (r->in.options) {
25040                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25041                 }
25042         }
25043         if (flags & NDR_OUT) {
25044                 if (r->out.info == NULL) {
25045                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25046                 }
25047                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25048                 if (*r->out.info) {
25049                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25050                 }
25051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25052         }
25053         return NDR_ERR_SUCCESS;
25054 }
25055
25056 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25057 {
25058         uint32_t _ptr_options;
25059         uint32_t _ptr_info;
25060         TALLOC_CTX *_mem_save_handle_0;
25061         TALLOC_CTX *_mem_save_options_0;
25062         TALLOC_CTX *_mem_save_info_0;
25063         TALLOC_CTX *_mem_save_info_1;
25064         if (flags & NDR_IN) {
25065                 ZERO_STRUCT(r->out);
25066
25067                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25068                         NDR_PULL_ALLOC(ndr, r->in.handle);
25069                 }
25070                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25071                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25072                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25073                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25076                 if (_ptr_options) {
25077                         NDR_PULL_ALLOC(ndr, r->in.options);
25078                 } else {
25079                         r->in.options = NULL;
25080                 }
25081                 if (r->in.options) {
25082                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25083                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25084                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25086                 }
25087                 NDR_PULL_ALLOC(ndr, r->out.info);
25088                 ZERO_STRUCTP(r->out.info);
25089         }
25090         if (flags & NDR_OUT) {
25091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25092                         NDR_PULL_ALLOC(ndr, r->out.info);
25093                 }
25094                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25095                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25097                 if (_ptr_info) {
25098                         NDR_PULL_ALLOC(ndr, *r->out.info);
25099                 } else {
25100                         *r->out.info = NULL;
25101                 }
25102                 if (*r->out.info) {
25103                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25104                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25105                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25107                 }
25108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25109                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25110         }
25111         return NDR_ERR_SUCCESS;
25112 }
25113
25114 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25115 {
25116         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25117         ndr->depth++;
25118         if (flags & NDR_SET_VALUES) {
25119                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25120         }
25121         if (flags & NDR_IN) {
25122                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25123                 ndr->depth++;
25124                 ndr_print_ptr(ndr, "handle", r->in.handle);
25125                 ndr->depth++;
25126                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25127                 ndr->depth--;
25128                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25129                 ndr_print_ptr(ndr, "options", r->in.options);
25130                 ndr->depth++;
25131                 if (r->in.options) {
25132                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25133                 }
25134                 ndr->depth--;
25135                 ndr->depth--;
25136         }
25137         if (flags & NDR_OUT) {
25138                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25139                 ndr->depth++;
25140                 ndr_print_ptr(ndr, "info", r->out.info);
25141                 ndr->depth++;
25142                 ndr_print_ptr(ndr, "info", *r->out.info);
25143                 ndr->depth++;
25144                 if (*r->out.info) {
25145                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25146                 }
25147                 ndr->depth--;
25148                 ndr->depth--;
25149                 ndr_print_WERROR(ndr, "result", r->out.result);
25150                 ndr->depth--;
25151         }
25152         ndr->depth--;
25153 }
25154
25155 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25156 {
25157         if (flags & NDR_IN) {
25158         }
25159         if (flags & NDR_OUT) {
25160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25161         }
25162         return NDR_ERR_SUCCESS;
25163 }
25164
25165 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25166 {
25167         if (flags & NDR_IN) {
25168         }
25169         if (flags & NDR_OUT) {
25170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25171         }
25172         return NDR_ERR_SUCCESS;
25173 }
25174
25175 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25176 {
25177         ndr_print_struct(ndr, name, "spoolss_44");
25178         ndr->depth++;
25179         if (flags & NDR_SET_VALUES) {
25180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25181         }
25182         if (flags & NDR_IN) {
25183                 ndr_print_struct(ndr, "in", "spoolss_44");
25184                 ndr->depth++;
25185                 ndr->depth--;
25186         }
25187         if (flags & NDR_OUT) {
25188                 ndr_print_struct(ndr, "out", "spoolss_44");
25189                 ndr->depth++;
25190                 ndr_print_WERROR(ndr, "result", r->out.result);
25191                 ndr->depth--;
25192         }
25193         ndr->depth--;
25194 }
25195
25196 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25197 {
25198         if (flags & NDR_IN) {
25199                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25200                 if (r->in.printername) {
25201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25203                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25204                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25205                 }
25206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25207                 if (r->in.datatype) {
25208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25212                 }
25213                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25214                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25216                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25217                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25218         }
25219         if (flags & NDR_OUT) {
25220                 if (r->out.handle == NULL) {
25221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25222                 }
25223                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25225         }
25226         return NDR_ERR_SUCCESS;
25227 }
25228
25229 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25230 {
25231         uint32_t _ptr_printername;
25232         uint32_t _ptr_datatype;
25233         TALLOC_CTX *_mem_save_printername_0;
25234         TALLOC_CTX *_mem_save_datatype_0;
25235         TALLOC_CTX *_mem_save_handle_0;
25236         if (flags & NDR_IN) {
25237                 ZERO_STRUCT(r->out);
25238
25239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25240                 if (_ptr_printername) {
25241                         NDR_PULL_ALLOC(ndr, r->in.printername);
25242                 } else {
25243                         r->in.printername = NULL;
25244                 }
25245                 if (r->in.printername) {
25246                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25247                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25250                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25251                                 return 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));
25252                         }
25253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25256                 }
25257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25258                 if (_ptr_datatype) {
25259                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25260                 } else {
25261                         r->in.datatype = NULL;
25262                 }
25263                 if (r->in.datatype) {
25264                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25265                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25268                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25269                                 return 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));
25270                         }
25271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25274                 }
25275                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25276                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25278                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25279                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25280                 NDR_PULL_ALLOC(ndr, r->out.handle);
25281                 ZERO_STRUCTP(r->out.handle);
25282         }
25283         if (flags & NDR_OUT) {
25284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25285                         NDR_PULL_ALLOC(ndr, r->out.handle);
25286                 }
25287                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25288                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25289                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25292         }
25293         return NDR_ERR_SUCCESS;
25294 }
25295
25296 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25297 {
25298         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25299         ndr->depth++;
25300         if (flags & NDR_SET_VALUES) {
25301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25302         }
25303         if (flags & NDR_IN) {
25304                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25305                 ndr->depth++;
25306                 ndr_print_ptr(ndr, "printername", r->in.printername);
25307                 ndr->depth++;
25308                 if (r->in.printername) {
25309                         ndr_print_string(ndr, "printername", r->in.printername);
25310                 }
25311                 ndr->depth--;
25312                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25313                 ndr->depth++;
25314                 if (r->in.datatype) {
25315                         ndr_print_string(ndr, "datatype", r->in.datatype);
25316                 }
25317                 ndr->depth--;
25318                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25319                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25320                 ndr_print_uint32(ndr, "level", r->in.level);
25321                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25322                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25323                 ndr->depth--;
25324         }
25325         if (flags & NDR_OUT) {
25326                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25327                 ndr->depth++;
25328                 ndr_print_ptr(ndr, "handle", r->out.handle);
25329                 ndr->depth++;
25330                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25331                 ndr->depth--;
25332                 ndr_print_WERROR(ndr, "result", r->out.result);
25333                 ndr->depth--;
25334         }
25335         ndr->depth--;
25336 }
25337
25338 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25339 {
25340         if (flags & NDR_IN) {
25341                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25342                 if (r->in.server) {
25343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25346                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25347                 }
25348                 if (r->in.info_ctr == NULL) {
25349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25350                 }
25351                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25352                 if (r->in.devmode_ctr == NULL) {
25353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25354                 }
25355                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25356                 if (r->in.secdesc_ctr == NULL) {
25357                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25358                 }
25359                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25360                 if (r->in.userlevel_ctr == NULL) {
25361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25362                 }
25363                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25364         }
25365         if (flags & NDR_OUT) {
25366                 if (r->out.handle == NULL) {
25367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25368                 }
25369                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25370                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25371         }
25372         return NDR_ERR_SUCCESS;
25373 }
25374
25375 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25376 {
25377         uint32_t _ptr_server;
25378         TALLOC_CTX *_mem_save_server_0;
25379         TALLOC_CTX *_mem_save_info_ctr_0;
25380         TALLOC_CTX *_mem_save_devmode_ctr_0;
25381         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25382         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25383         TALLOC_CTX *_mem_save_handle_0;
25384         if (flags & NDR_IN) {
25385                 ZERO_STRUCT(r->out);
25386
25387                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25388                 if (_ptr_server) {
25389                         NDR_PULL_ALLOC(ndr, r->in.server);
25390                 } else {
25391                         r->in.server = NULL;
25392                 }
25393                 if (r->in.server) {
25394                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25395                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25398                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25399                                 return 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));
25400                         }
25401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25404                 }
25405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25406                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25407                 }
25408                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25410                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25413                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25414                 }
25415                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25416                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25417                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25419                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25420                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25421                 }
25422                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25423                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25424                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25425                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25427                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25428                 }
25429                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25430                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25431                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25432                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25433                 NDR_PULL_ALLOC(ndr, r->out.handle);
25434                 ZERO_STRUCTP(r->out.handle);
25435         }
25436         if (flags & NDR_OUT) {
25437                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25438                         NDR_PULL_ALLOC(ndr, r->out.handle);
25439                 }
25440                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25441                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25442                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25443                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25444                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25445         }
25446         return NDR_ERR_SUCCESS;
25447 }
25448
25449 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25450 {
25451         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25452         ndr->depth++;
25453         if (flags & NDR_SET_VALUES) {
25454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25455         }
25456         if (flags & NDR_IN) {
25457                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25458                 ndr->depth++;
25459                 ndr_print_ptr(ndr, "server", r->in.server);
25460                 ndr->depth++;
25461                 if (r->in.server) {
25462                         ndr_print_string(ndr, "server", r->in.server);
25463                 }
25464                 ndr->depth--;
25465                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25466                 ndr->depth++;
25467                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25468                 ndr->depth--;
25469                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25470                 ndr->depth++;
25471                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25472                 ndr->depth--;
25473                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25474                 ndr->depth++;
25475                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25476                 ndr->depth--;
25477                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25478                 ndr->depth++;
25479                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25480                 ndr->depth--;
25481                 ndr->depth--;
25482         }
25483         if (flags & NDR_OUT) {
25484                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25485                 ndr->depth++;
25486                 ndr_print_ptr(ndr, "handle", r->out.handle);
25487                 ndr->depth++;
25488                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25489                 ndr->depth--;
25490                 ndr_print_WERROR(ndr, "result", r->out.result);
25491                 ndr->depth--;
25492         }
25493         ndr->depth--;
25494 }
25495
25496 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25497 {
25498         if (flags & NDR_IN) {
25499         }
25500         if (flags & NDR_OUT) {
25501                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25502         }
25503         return NDR_ERR_SUCCESS;
25504 }
25505
25506 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25507 {
25508         if (flags & NDR_IN) {
25509         }
25510         if (flags & NDR_OUT) {
25511                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25512         }
25513         return NDR_ERR_SUCCESS;
25514 }
25515
25516 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25517 {
25518         ndr_print_struct(ndr, name, "spoolss_47");
25519         ndr->depth++;
25520         if (flags & NDR_SET_VALUES) {
25521                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25522         }
25523         if (flags & NDR_IN) {
25524                 ndr_print_struct(ndr, "in", "spoolss_47");
25525                 ndr->depth++;
25526                 ndr->depth--;
25527         }
25528         if (flags & NDR_OUT) {
25529                 ndr_print_struct(ndr, "out", "spoolss_47");
25530                 ndr->depth++;
25531                 ndr_print_WERROR(ndr, "result", r->out.result);
25532                 ndr->depth--;
25533         }
25534         ndr->depth--;
25535 }
25536
25537 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25538 {
25539         if (flags & NDR_IN) {
25540                 if (r->in.handle == NULL) {
25541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25542                 }
25543                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25547         }
25548         if (flags & NDR_OUT) {
25549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25550                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25551                 if (r->out.value_needed == NULL) {
25552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25553                 }
25554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25555                 if (r->out.type == NULL) {
25556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25557                 }
25558                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25559                 {
25560                         uint32_t _flags_save_uint8 = ndr->flags;
25561                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25562                         if (r->out.data == NULL) {
25563                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25564                         }
25565                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25566                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25567                         ndr->flags = _flags_save_uint8;
25568                 }
25569                 if (r->out.data_needed == NULL) {
25570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25571                 }
25572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25573                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25574         }
25575         return NDR_ERR_SUCCESS;
25576 }
25577
25578 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25579 {
25580         TALLOC_CTX *_mem_save_handle_0;
25581         TALLOC_CTX *_mem_save_value_needed_0;
25582         TALLOC_CTX *_mem_save_type_0;
25583         TALLOC_CTX *_mem_save_data_needed_0;
25584         if (flags & NDR_IN) {
25585                 ZERO_STRUCT(r->out);
25586
25587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25588                         NDR_PULL_ALLOC(ndr, r->in.handle);
25589                 }
25590                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25591                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25592                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25597                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25598                 ZERO_STRUCTP(r->out.value_needed);
25599                 NDR_PULL_ALLOC(ndr, r->out.type);
25600                 ZERO_STRUCTP(r->out.type);
25601                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
25602                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
25603                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25604                 ZERO_STRUCTP(r->out.data_needed);
25605         }
25606         if (flags & NDR_OUT) {
25607                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25608                 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));
25609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25610                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25611                 }
25612                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25613                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25617                         NDR_PULL_ALLOC(ndr, r->out.type);
25618                 }
25619                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25621                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
25622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25623                 {
25624                         uint32_t _flags_save_uint8 = ndr->flags;
25625                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25626                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
25627                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25628                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
25629                         }
25630                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
25631                         ndr->flags = _flags_save_uint8;
25632                 }
25633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25634                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25635                 }
25636                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25637                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25640                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25641                 if (r->out.value_name) {
25642                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25643                 }
25644                 if (r->out.data) {
25645                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
25646                 }
25647         }
25648         return NDR_ERR_SUCCESS;
25649 }
25650
25651 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25652 {
25653         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25654         ndr->depth++;
25655         if (flags & NDR_SET_VALUES) {
25656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25657         }
25658         if (flags & NDR_IN) {
25659                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25660                 ndr->depth++;
25661                 ndr_print_ptr(ndr, "handle", r->in.handle);
25662                 ndr->depth++;
25663                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25664                 ndr->depth--;
25665                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25666                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25667                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25668                 ndr->depth--;
25669         }
25670         if (flags & NDR_OUT) {
25671                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25672                 ndr->depth++;
25673                 ndr_print_string(ndr, "value_name", r->out.value_name);
25674                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25675                 ndr->depth++;
25676                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25677                 ndr->depth--;
25678                 ndr_print_ptr(ndr, "type", r->out.type);
25679                 ndr->depth++;
25680                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
25681                 ndr->depth--;
25682                 ndr_print_ptr(ndr, "data", r->out.data);
25683                 ndr->depth++;
25684                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
25685                 ndr->depth--;
25686                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25687                 ndr->depth++;
25688                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25689                 ndr->depth--;
25690                 ndr_print_WERROR(ndr, "result", r->out.result);
25691                 ndr->depth--;
25692         }
25693         ndr->depth--;
25694 }
25695
25696 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25697 {
25698         if (flags & NDR_IN) {
25699                 if (r->in.handle == NULL) {
25700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25701                 }
25702                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25706                 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));
25707         }
25708         if (flags & NDR_OUT) {
25709                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25710         }
25711         return NDR_ERR_SUCCESS;
25712 }
25713
25714 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25715 {
25716         TALLOC_CTX *_mem_save_handle_0;
25717         if (flags & NDR_IN) {
25718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25719                         NDR_PULL_ALLOC(ndr, r->in.handle);
25720                 }
25721                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25722                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25723                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25724                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25725                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25726                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25727                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25728                         return 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));
25729                 }
25730                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25731                 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));
25732         }
25733         if (flags & NDR_OUT) {
25734                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25735         }
25736         return NDR_ERR_SUCCESS;
25737 }
25738
25739 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25740 {
25741         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25742         ndr->depth++;
25743         if (flags & NDR_SET_VALUES) {
25744                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25745         }
25746         if (flags & NDR_IN) {
25747                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25748                 ndr->depth++;
25749                 ndr_print_ptr(ndr, "handle", r->in.handle);
25750                 ndr->depth++;
25751                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25752                 ndr->depth--;
25753                 ndr_print_string(ndr, "value_name", r->in.value_name);
25754                 ndr->depth--;
25755         }
25756         if (flags & NDR_OUT) {
25757                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25758                 ndr->depth++;
25759                 ndr_print_WERROR(ndr, "result", r->out.result);
25760                 ndr->depth--;
25761         }
25762         ndr->depth--;
25763 }
25764
25765 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25766 {
25767         if (flags & NDR_IN) {
25768         }
25769         if (flags & NDR_OUT) {
25770                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25771         }
25772         return NDR_ERR_SUCCESS;
25773 }
25774
25775 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25776 {
25777         if (flags & NDR_IN) {
25778         }
25779         if (flags & NDR_OUT) {
25780                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25781         }
25782         return NDR_ERR_SUCCESS;
25783 }
25784
25785 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25786 {
25787         ndr_print_struct(ndr, name, "spoolss_4a");
25788         ndr->depth++;
25789         if (flags & NDR_SET_VALUES) {
25790                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25791         }
25792         if (flags & NDR_IN) {
25793                 ndr_print_struct(ndr, "in", "spoolss_4a");
25794                 ndr->depth++;
25795                 ndr->depth--;
25796         }
25797         if (flags & NDR_OUT) {
25798                 ndr_print_struct(ndr, "out", "spoolss_4a");
25799                 ndr->depth++;
25800                 ndr_print_WERROR(ndr, "result", r->out.result);
25801                 ndr->depth--;
25802         }
25803         ndr->depth--;
25804 }
25805
25806 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25807 {
25808         if (flags & NDR_IN) {
25809         }
25810         if (flags & NDR_OUT) {
25811                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25812         }
25813         return NDR_ERR_SUCCESS;
25814 }
25815
25816 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25817 {
25818         if (flags & NDR_IN) {
25819         }
25820         if (flags & NDR_OUT) {
25821                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25822         }
25823         return NDR_ERR_SUCCESS;
25824 }
25825
25826 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25827 {
25828         ndr_print_struct(ndr, name, "spoolss_4b");
25829         ndr->depth++;
25830         if (flags & NDR_SET_VALUES) {
25831                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25832         }
25833         if (flags & NDR_IN) {
25834                 ndr_print_struct(ndr, "in", "spoolss_4b");
25835                 ndr->depth++;
25836                 ndr->depth--;
25837         }
25838         if (flags & NDR_OUT) {
25839                 ndr_print_struct(ndr, "out", "spoolss_4b");
25840                 ndr->depth++;
25841                 ndr_print_WERROR(ndr, "result", r->out.result);
25842                 ndr->depth--;
25843         }
25844         ndr->depth--;
25845 }
25846
25847 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25848 {
25849         if (flags & NDR_IN) {
25850         }
25851         if (flags & NDR_OUT) {
25852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25853         }
25854         return NDR_ERR_SUCCESS;
25855 }
25856
25857 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25858 {
25859         if (flags & NDR_IN) {
25860         }
25861         if (flags & NDR_OUT) {
25862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25863         }
25864         return NDR_ERR_SUCCESS;
25865 }
25866
25867 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25868 {
25869         ndr_print_struct(ndr, name, "spoolss_4c");
25870         ndr->depth++;
25871         if (flags & NDR_SET_VALUES) {
25872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25873         }
25874         if (flags & NDR_IN) {
25875                 ndr_print_struct(ndr, "in", "spoolss_4c");
25876                 ndr->depth++;
25877                 ndr->depth--;
25878         }
25879         if (flags & NDR_OUT) {
25880                 ndr_print_struct(ndr, "out", "spoolss_4c");
25881                 ndr->depth++;
25882                 ndr_print_WERROR(ndr, "result", r->out.result);
25883                 ndr->depth--;
25884         }
25885         ndr->depth--;
25886 }
25887
25888 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25889 {
25890         if (flags & NDR_IN) {
25891                 if (r->in.handle == NULL) {
25892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25893                 }
25894                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25898                 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));
25899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25902                 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));
25903                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
25904                 if (r->in.buffer == NULL) {
25905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25906                 }
25907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25908                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25910         }
25911         if (flags & NDR_OUT) {
25912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25913         }
25914         return NDR_ERR_SUCCESS;
25915 }
25916
25917 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25918 {
25919         TALLOC_CTX *_mem_save_handle_0;
25920         if (flags & NDR_IN) {
25921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25922                         NDR_PULL_ALLOC(ndr, r->in.handle);
25923                 }
25924                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25926                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25928                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25929                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25930                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25931                         return 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));
25932                 }
25933                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25934                 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));
25935                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25936                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25937                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25938                         return 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));
25939                 }
25940                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25941                 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));
25942                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
25943                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25944                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25945                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25946                 }
25947                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25949                 if (r->in.buffer) {
25950                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25951                 }
25952         }
25953         if (flags & NDR_OUT) {
25954                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25955         }
25956         return NDR_ERR_SUCCESS;
25957 }
25958
25959 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25960 {
25961         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25962         ndr->depth++;
25963         if (flags & NDR_SET_VALUES) {
25964                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25965         }
25966         if (flags & NDR_IN) {
25967                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25968                 ndr->depth++;
25969                 ndr_print_ptr(ndr, "handle", r->in.handle);
25970                 ndr->depth++;
25971                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25972                 ndr->depth--;
25973                 ndr_print_string(ndr, "key_name", r->in.key_name);
25974                 ndr_print_string(ndr, "value_name", r->in.value_name);
25975                 ndr_print_winreg_Type(ndr, "type", r->in.type);
25976                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25977                 ndr->depth++;
25978                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25979                 ndr->depth--;
25980                 ndr_print_uint32(ndr, "offered", r->in.offered);
25981                 ndr->depth--;
25982         }
25983         if (flags & NDR_OUT) {
25984                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25985                 ndr->depth++;
25986                 ndr_print_WERROR(ndr, "result", r->out.result);
25987                 ndr->depth--;
25988         }
25989         ndr->depth--;
25990 }
25991
25992 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25993 {
25994         if (flags & NDR_IN) {
25995                 if (r->in.handle == NULL) {
25996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25997                 }
25998                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26002                 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));
26003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26006                 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));
26007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26008         }
26009         if (flags & NDR_OUT) {
26010                 if (r->out.type == NULL) {
26011                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26012                 }
26013                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26014                 if (r->out.buffer == NULL) {
26015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26016                 }
26017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26018                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26019                 if (r->out.needed == NULL) {
26020                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26021                 }
26022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26023                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26024         }
26025         return NDR_ERR_SUCCESS;
26026 }
26027
26028 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26029 {
26030         TALLOC_CTX *_mem_save_handle_0;
26031         TALLOC_CTX *_mem_save_type_0;
26032         TALLOC_CTX *_mem_save_needed_0;
26033         if (flags & NDR_IN) {
26034                 ZERO_STRUCT(r->out);
26035
26036                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26037                         NDR_PULL_ALLOC(ndr, r->in.handle);
26038                 }
26039                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26040                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26041                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26042                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26043                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26044                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26045                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26046                         return 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));
26047                 }
26048                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26049                 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));
26050                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26051                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26052                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26053                         return 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));
26054                 }
26055                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26056                 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));
26057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26058                 NDR_PULL_ALLOC(ndr, r->out.type);
26059                 ZERO_STRUCTP(r->out.type);
26060                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26061                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26062                 NDR_PULL_ALLOC(ndr, r->out.needed);
26063                 ZERO_STRUCTP(r->out.needed);
26064         }
26065         if (flags & NDR_OUT) {
26066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26067                         NDR_PULL_ALLOC(ndr, r->out.type);
26068                 }
26069                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26070                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26071                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26073                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26075                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26076                 }
26077                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26079                         NDR_PULL_ALLOC(ndr, r->out.needed);
26080                 }
26081                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26082                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26086                 if (r->out.buffer) {
26087                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26088                 }
26089         }
26090         return NDR_ERR_SUCCESS;
26091 }
26092
26093 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26094 {
26095         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26096         ndr->depth++;
26097         if (flags & NDR_SET_VALUES) {
26098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26099         }
26100         if (flags & NDR_IN) {
26101                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26102                 ndr->depth++;
26103                 ndr_print_ptr(ndr, "handle", r->in.handle);
26104                 ndr->depth++;
26105                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26106                 ndr->depth--;
26107                 ndr_print_string(ndr, "key_name", r->in.key_name);
26108                 ndr_print_string(ndr, "value_name", r->in.value_name);
26109                 ndr_print_uint32(ndr, "offered", r->in.offered);
26110                 ndr->depth--;
26111         }
26112         if (flags & NDR_OUT) {
26113                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26114                 ndr->depth++;
26115                 ndr_print_ptr(ndr, "type", r->out.type);
26116                 ndr->depth++;
26117                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26118                 ndr->depth--;
26119                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26120                 ndr->depth++;
26121                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26122                 ndr->depth--;
26123                 ndr_print_ptr(ndr, "needed", r->out.needed);
26124                 ndr->depth++;
26125                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26126                 ndr->depth--;
26127                 ndr_print_WERROR(ndr, "result", r->out.result);
26128                 ndr->depth--;
26129         }
26130         ndr->depth--;
26131 }
26132
26133 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26134 {
26135         if (flags & NDR_IN) {
26136                 if (r->in.handle == NULL) {
26137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26138                 }
26139                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26143                 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));
26144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26145         }
26146         if (flags & NDR_OUT) {
26147                 if (r->out.buffer == NULL) {
26148                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26149                 }
26150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26151                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26152                 if (r->out.needed == NULL) {
26153                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26154                 }
26155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26156                 if (r->out.count == NULL) {
26157                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26158                 }
26159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26161         }
26162         return NDR_ERR_SUCCESS;
26163 }
26164
26165 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26166 {
26167         TALLOC_CTX *_mem_save_handle_0;
26168         TALLOC_CTX *_mem_save_needed_0;
26169         TALLOC_CTX *_mem_save_count_0;
26170         if (flags & NDR_IN) {
26171                 ZERO_STRUCT(r->out);
26172
26173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26174                         NDR_PULL_ALLOC(ndr, r->in.handle);
26175                 }
26176                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26177                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26178                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26180                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26181                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26182                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26183                         return 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));
26184                 }
26185                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26186                 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));
26187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26188                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26189                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26190                 NDR_PULL_ALLOC(ndr, r->out.needed);
26191                 ZERO_STRUCTP(r->out.needed);
26192                 NDR_PULL_ALLOC(ndr, r->out.count);
26193                 ZERO_STRUCTP(r->out.count);
26194         }
26195         if (flags & NDR_OUT) {
26196                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26198                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26199                 }
26200                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26202                         NDR_PULL_ALLOC(ndr, r->out.needed);
26203                 }
26204                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26205                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26208                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26209                         NDR_PULL_ALLOC(ndr, r->out.count);
26210                 }
26211                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26212                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26214                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26215                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26216                 if (r->out.buffer) {
26217                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26218                 }
26219         }
26220         return NDR_ERR_SUCCESS;
26221 }
26222
26223 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26224 {
26225         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26226         ndr->depth++;
26227         if (flags & NDR_SET_VALUES) {
26228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26229         }
26230         if (flags & NDR_IN) {
26231                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26232                 ndr->depth++;
26233                 ndr_print_ptr(ndr, "handle", r->in.handle);
26234                 ndr->depth++;
26235                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26236                 ndr->depth--;
26237                 ndr_print_string(ndr, "key_name", r->in.key_name);
26238                 ndr_print_uint32(ndr, "offered", r->in.offered);
26239                 ndr->depth--;
26240         }
26241         if (flags & NDR_OUT) {
26242                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26243                 ndr->depth++;
26244                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26245                 ndr->depth++;
26246                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26247                 ndr->depth--;
26248                 ndr_print_ptr(ndr, "needed", r->out.needed);
26249                 ndr->depth++;
26250                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26251                 ndr->depth--;
26252                 ndr_print_ptr(ndr, "count", r->out.count);
26253                 ndr->depth++;
26254                 ndr_print_uint32(ndr, "count", *r->out.count);
26255                 ndr->depth--;
26256                 ndr_print_WERROR(ndr, "result", r->out.result);
26257                 ndr->depth--;
26258         }
26259         ndr->depth--;
26260 }
26261
26262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26263 {
26264         if (flags & NDR_IN) {
26265                 if (r->in.handle == NULL) {
26266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26267                 }
26268                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26272                 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));
26273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26274         }
26275         if (flags & NDR_OUT) {
26276                 {
26277                         uint32_t _flags_save_string_array = ndr->flags;
26278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26279                         if (r->out.key_buffer == NULL) {
26280                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26281                         }
26282                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
26283                         if (*r->out.key_buffer) {
26284                                 {
26285                                         struct ndr_push *_ndr_key_buffer;
26286                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26287                                         NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
26288                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26289                                 }
26290                         }
26291                         ndr->flags = _flags_save_string_array;
26292                 }
26293                 if (r->out.needed == NULL) {
26294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26295                 }
26296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26297                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26298         }
26299         return NDR_ERR_SUCCESS;
26300 }
26301
26302 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26303 {
26304         uint32_t _ptr_key_buffer;
26305         TALLOC_CTX *_mem_save_handle_0;
26306         TALLOC_CTX *_mem_save_key_buffer_0;
26307         TALLOC_CTX *_mem_save_key_buffer_1;
26308         TALLOC_CTX *_mem_save_needed_0;
26309         if (flags & NDR_IN) {
26310                 ZERO_STRUCT(r->out);
26311
26312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26313                         NDR_PULL_ALLOC(ndr, r->in.handle);
26314                 }
26315                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26317                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26319                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26320                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26321                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26322                         return 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));
26323                 }
26324                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26325                 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));
26326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26327                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26328                 ZERO_STRUCTP(r->out.key_buffer);
26329                 NDR_PULL_ALLOC(ndr, r->out.needed);
26330                 ZERO_STRUCTP(r->out.needed);
26331         }
26332         if (flags & NDR_OUT) {
26333                 {
26334                         uint32_t _flags_save_string_array = ndr->flags;
26335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26336                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26337                                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26338                         }
26339                         _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26340                         NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
26342                         if (_ptr_key_buffer) {
26343                                 NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
26344                         } else {
26345                                 *r->out.key_buffer = NULL;
26346                         }
26347                         if (*r->out.key_buffer) {
26348                                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26349                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
26350                                 {
26351                                         struct ndr_pull *_ndr_key_buffer;
26352                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26353                                         NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
26354                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26355                                 }
26356                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26357                         }
26358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26359                         ndr->flags = _flags_save_string_array;
26360                 }
26361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26362                         NDR_PULL_ALLOC(ndr, r->out.needed);
26363                 }
26364                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26365                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26368                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26369         }
26370         return NDR_ERR_SUCCESS;
26371 }
26372
26373 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26374 {
26375         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26376         ndr->depth++;
26377         if (flags & NDR_SET_VALUES) {
26378                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26379         }
26380         if (flags & NDR_IN) {
26381                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26382                 ndr->depth++;
26383                 ndr_print_ptr(ndr, "handle", r->in.handle);
26384                 ndr->depth++;
26385                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26386                 ndr->depth--;
26387                 ndr_print_string(ndr, "key_name", r->in.key_name);
26388                 ndr_print_uint32(ndr, "offered", r->in.offered);
26389                 ndr->depth--;
26390         }
26391         if (flags & NDR_OUT) {
26392                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26393                 ndr->depth++;
26394                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26395                 ndr->depth++;
26396                 ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
26397                 ndr->depth++;
26398                 if (*r->out.key_buffer) {
26399                         ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
26400                 }
26401                 ndr->depth--;
26402                 ndr->depth--;
26403                 ndr_print_ptr(ndr, "needed", r->out.needed);
26404                 ndr->depth++;
26405                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26406                 ndr->depth--;
26407                 ndr_print_WERROR(ndr, "result", r->out.result);
26408                 ndr->depth--;
26409         }
26410         ndr->depth--;
26411 }
26412
26413 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26414 {
26415         if (flags & NDR_IN) {
26416                 if (r->in.handle == NULL) {
26417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26418                 }
26419                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26423                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26427                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26428         }
26429         if (flags & NDR_OUT) {
26430                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26431         }
26432         return NDR_ERR_SUCCESS;
26433 }
26434
26435 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26436 {
26437         TALLOC_CTX *_mem_save_handle_0;
26438         if (flags & NDR_IN) {
26439                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26440                         NDR_PULL_ALLOC(ndr, r->in.handle);
26441                 }
26442                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26443                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26444                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26445                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26446                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26447                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26448                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26449                         return 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));
26450                 }
26451                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26452                 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));
26453                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26454                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26455                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26456                         return 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));
26457                 }
26458                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26459                 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));
26460         }
26461         if (flags & NDR_OUT) {
26462                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26463         }
26464         return NDR_ERR_SUCCESS;
26465 }
26466
26467 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26468 {
26469         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26470         ndr->depth++;
26471         if (flags & NDR_SET_VALUES) {
26472                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26473         }
26474         if (flags & NDR_IN) {
26475                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26476                 ndr->depth++;
26477                 ndr_print_ptr(ndr, "handle", r->in.handle);
26478                 ndr->depth++;
26479                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26480                 ndr->depth--;
26481                 ndr_print_string(ndr, "key_name", r->in.key_name);
26482                 ndr_print_string(ndr, "value_name", r->in.value_name);
26483                 ndr->depth--;
26484         }
26485         if (flags & NDR_OUT) {
26486                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26487                 ndr->depth++;
26488                 ndr_print_WERROR(ndr, "result", r->out.result);
26489                 ndr->depth--;
26490         }
26491         ndr->depth--;
26492 }
26493
26494 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26495 {
26496         if (flags & NDR_IN) {
26497                 if (r->in.handle == NULL) {
26498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26499                 }
26500                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26504                 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));
26505         }
26506         if (flags & NDR_OUT) {
26507                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26508         }
26509         return NDR_ERR_SUCCESS;
26510 }
26511
26512 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26513 {
26514         TALLOC_CTX *_mem_save_handle_0;
26515         if (flags & NDR_IN) {
26516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26517                         NDR_PULL_ALLOC(ndr, r->in.handle);
26518                 }
26519                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26520                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26521                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26523                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26524                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26525                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26526                         return 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));
26527                 }
26528                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26529                 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));
26530         }
26531         if (flags & NDR_OUT) {
26532                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26533         }
26534         return NDR_ERR_SUCCESS;
26535 }
26536
26537 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26538 {
26539         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26540         ndr->depth++;
26541         if (flags & NDR_SET_VALUES) {
26542                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26543         }
26544         if (flags & NDR_IN) {
26545                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26546                 ndr->depth++;
26547                 ndr_print_ptr(ndr, "handle", r->in.handle);
26548                 ndr->depth++;
26549                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26550                 ndr->depth--;
26551                 ndr_print_string(ndr, "key_name", r->in.key_name);
26552                 ndr->depth--;
26553         }
26554         if (flags & NDR_OUT) {
26555                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26556                 ndr->depth++;
26557                 ndr_print_WERROR(ndr, "result", r->out.result);
26558                 ndr->depth--;
26559         }
26560         ndr->depth--;
26561 }
26562
26563 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26564 {
26565         if (flags & NDR_IN) {
26566         }
26567         if (flags & NDR_OUT) {
26568                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26569         }
26570         return NDR_ERR_SUCCESS;
26571 }
26572
26573 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26574 {
26575         if (flags & NDR_IN) {
26576         }
26577         if (flags & NDR_OUT) {
26578                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26579         }
26580         return NDR_ERR_SUCCESS;
26581 }
26582
26583 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26584 {
26585         ndr_print_struct(ndr, name, "spoolss_53");
26586         ndr->depth++;
26587         if (flags & NDR_SET_VALUES) {
26588                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26589         }
26590         if (flags & NDR_IN) {
26591                 ndr_print_struct(ndr, "in", "spoolss_53");
26592                 ndr->depth++;
26593                 ndr->depth--;
26594         }
26595         if (flags & NDR_OUT) {
26596                 ndr_print_struct(ndr, "out", "spoolss_53");
26597                 ndr->depth++;
26598                 ndr_print_WERROR(ndr, "result", r->out.result);
26599                 ndr->depth--;
26600         }
26601         ndr->depth--;
26602 }
26603
26604 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26605 {
26606         if (flags & NDR_IN) {
26607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26608                 if (r->in.server) {
26609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26610                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26611                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26612                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26613                 }
26614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26617                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26621                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26622                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26624         }
26625         if (flags & NDR_OUT) {
26626                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26627         }
26628         return NDR_ERR_SUCCESS;
26629 }
26630
26631 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26632 {
26633         uint32_t _ptr_server;
26634         TALLOC_CTX *_mem_save_server_0;
26635         if (flags & NDR_IN) {
26636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26637                 if (_ptr_server) {
26638                         NDR_PULL_ALLOC(ndr, r->in.server);
26639                 } else {
26640                         r->in.server = NULL;
26641                 }
26642                 if (r->in.server) {
26643                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26644                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26645                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26646                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26647                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26648                                 return 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));
26649                         }
26650                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26651                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26653                 }
26654                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26655                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26656                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26657                         return 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));
26658                 }
26659                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26660                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26661                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26662                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26663                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26664                         return 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));
26665                 }
26666                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26667                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26668                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26670         }
26671         if (flags & NDR_OUT) {
26672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26673         }
26674         return NDR_ERR_SUCCESS;
26675 }
26676
26677 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26678 {
26679         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26680         ndr->depth++;
26681         if (flags & NDR_SET_VALUES) {
26682                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26683         }
26684         if (flags & NDR_IN) {
26685                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26686                 ndr->depth++;
26687                 ndr_print_ptr(ndr, "server", r->in.server);
26688                 ndr->depth++;
26689                 if (r->in.server) {
26690                         ndr_print_string(ndr, "server", r->in.server);
26691                 }
26692                 ndr->depth--;
26693                 ndr_print_string(ndr, "architecture", r->in.architecture);
26694                 ndr_print_string(ndr, "driver", r->in.driver);
26695                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26696                 ndr_print_uint32(ndr, "version", r->in.version);
26697                 ndr->depth--;
26698         }
26699         if (flags & NDR_OUT) {
26700                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26701                 ndr->depth++;
26702                 ndr_print_WERROR(ndr, "result", r->out.result);
26703                 ndr->depth--;
26704         }
26705         ndr->depth--;
26706 }
26707
26708 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26709 {
26710         if (flags & NDR_IN) {
26711         }
26712         if (flags & NDR_OUT) {
26713                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26714         }
26715         return NDR_ERR_SUCCESS;
26716 }
26717
26718 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26719 {
26720         if (flags & NDR_IN) {
26721         }
26722         if (flags & NDR_OUT) {
26723                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26724         }
26725         return NDR_ERR_SUCCESS;
26726 }
26727
26728 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26729 {
26730         ndr_print_struct(ndr, name, "spoolss_55");
26731         ndr->depth++;
26732         if (flags & NDR_SET_VALUES) {
26733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26734         }
26735         if (flags & NDR_IN) {
26736                 ndr_print_struct(ndr, "in", "spoolss_55");
26737                 ndr->depth++;
26738                 ndr->depth--;
26739         }
26740         if (flags & NDR_OUT) {
26741                 ndr_print_struct(ndr, "out", "spoolss_55");
26742                 ndr->depth++;
26743                 ndr_print_WERROR(ndr, "result", r->out.result);
26744                 ndr->depth--;
26745         }
26746         ndr->depth--;
26747 }
26748
26749 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26750 {
26751         if (flags & NDR_IN) {
26752         }
26753         if (flags & NDR_OUT) {
26754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26755         }
26756         return NDR_ERR_SUCCESS;
26757 }
26758
26759 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26760 {
26761         if (flags & NDR_IN) {
26762         }
26763         if (flags & NDR_OUT) {
26764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26765         }
26766         return NDR_ERR_SUCCESS;
26767 }
26768
26769 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26770 {
26771         ndr_print_struct(ndr, name, "spoolss_56");
26772         ndr->depth++;
26773         if (flags & NDR_SET_VALUES) {
26774                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26775         }
26776         if (flags & NDR_IN) {
26777                 ndr_print_struct(ndr, "in", "spoolss_56");
26778                 ndr->depth++;
26779                 ndr->depth--;
26780         }
26781         if (flags & NDR_OUT) {
26782                 ndr_print_struct(ndr, "out", "spoolss_56");
26783                 ndr->depth++;
26784                 ndr_print_WERROR(ndr, "result", r->out.result);
26785                 ndr->depth--;
26786         }
26787         ndr->depth--;
26788 }
26789
26790 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26791 {
26792         if (flags & NDR_IN) {
26793         }
26794         if (flags & NDR_OUT) {
26795                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26796         }
26797         return NDR_ERR_SUCCESS;
26798 }
26799
26800 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26801 {
26802         if (flags & NDR_IN) {
26803         }
26804         if (flags & NDR_OUT) {
26805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26806         }
26807         return NDR_ERR_SUCCESS;
26808 }
26809
26810 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26811 {
26812         ndr_print_struct(ndr, name, "spoolss_57");
26813         ndr->depth++;
26814         if (flags & NDR_SET_VALUES) {
26815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26816         }
26817         if (flags & NDR_IN) {
26818                 ndr_print_struct(ndr, "in", "spoolss_57");
26819                 ndr->depth++;
26820                 ndr->depth--;
26821         }
26822         if (flags & NDR_OUT) {
26823                 ndr_print_struct(ndr, "out", "spoolss_57");
26824                 ndr->depth++;
26825                 ndr_print_WERROR(ndr, "result", r->out.result);
26826                 ndr->depth--;
26827         }
26828         ndr->depth--;
26829 }
26830
26831 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26832 {
26833         if (flags & NDR_IN) {
26834                 if (r->in.handle == NULL) {
26835                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26836                 }
26837                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26841                 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));
26842                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26845                 if (r->in.status_code == NULL) {
26846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26847                 }
26848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26849         }
26850         if (flags & NDR_OUT) {
26851                 if (r->out.out_data == NULL) {
26852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26853                 }
26854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26855                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26856                 if (r->out.needed == NULL) {
26857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26858                 }
26859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26860                 if (r->out.status_code == NULL) {
26861                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26862                 }
26863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26864                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26865         }
26866         return NDR_ERR_SUCCESS;
26867 }
26868
26869 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26870 {
26871         TALLOC_CTX *_mem_save_handle_0;
26872         TALLOC_CTX *_mem_save_needed_0;
26873         TALLOC_CTX *_mem_save_status_code_0;
26874         if (flags & NDR_IN) {
26875                 ZERO_STRUCT(r->out);
26876
26877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26878                         NDR_PULL_ALLOC(ndr, r->in.handle);
26879                 }
26880                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26881                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26882                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26884                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26885                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26886                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26887                         return 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));
26888                 }
26889                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26890                 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));
26891                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26894                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26895                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26896                 }
26897                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26898                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26901                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26902                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26903                 NDR_PULL_ALLOC(ndr, r->out.needed);
26904                 ZERO_STRUCTP(r->out.needed);
26905                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26906                 *r->out.status_code = *r->in.status_code;
26907         }
26908         if (flags & NDR_OUT) {
26909                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26910                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26911                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26912                 }
26913                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26915                         NDR_PULL_ALLOC(ndr, r->out.needed);
26916                 }
26917                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26918                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26922                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26923                 }
26924                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26925                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26928                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26929                 if (r->out.out_data) {
26930                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26931                 }
26932         }
26933         return NDR_ERR_SUCCESS;
26934 }
26935
26936 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26937 {
26938         ndr_print_struct(ndr, name, "spoolss_XcvData");
26939         ndr->depth++;
26940         if (flags & NDR_SET_VALUES) {
26941                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26942         }
26943         if (flags & NDR_IN) {
26944                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26945                 ndr->depth++;
26946                 ndr_print_ptr(ndr, "handle", r->in.handle);
26947                 ndr->depth++;
26948                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26949                 ndr->depth--;
26950                 ndr_print_string(ndr, "function_name", r->in.function_name);
26951                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26952                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26953                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26954                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26955                 ndr->depth++;
26956                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26957                 ndr->depth--;
26958                 ndr->depth--;
26959         }
26960         if (flags & NDR_OUT) {
26961                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26962                 ndr->depth++;
26963                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26964                 ndr->depth++;
26965                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26966                 ndr->depth--;
26967                 ndr_print_ptr(ndr, "needed", r->out.needed);
26968                 ndr->depth++;
26969                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26970                 ndr->depth--;
26971                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26972                 ndr->depth++;
26973                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26974                 ndr->depth--;
26975                 ndr_print_WERROR(ndr, "result", r->out.result);
26976                 ndr->depth--;
26977         }
26978         ndr->depth--;
26979 }
26980
26981 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26982 {
26983         if (flags & NDR_IN) {
26984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26985                 if (r->in.servername) {
26986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26988                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26989                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26990                 }
26991                 if (r->in.info_ctr == NULL) {
26992                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26993                 }
26994                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26995                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26996         }
26997         if (flags & NDR_OUT) {
26998                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26999         }
27000         return NDR_ERR_SUCCESS;
27001 }
27002
27003 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27004 {
27005         uint32_t _ptr_servername;
27006         TALLOC_CTX *_mem_save_servername_0;
27007         TALLOC_CTX *_mem_save_info_ctr_0;
27008         if (flags & NDR_IN) {
27009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27010                 if (_ptr_servername) {
27011                         NDR_PULL_ALLOC(ndr, r->in.servername);
27012                 } else {
27013                         r->in.servername = NULL;
27014                 }
27015                 if (r->in.servername) {
27016                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27017                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27020                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27021                                 return 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));
27022                         }
27023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27026                 }
27027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27028                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27029                 }
27030                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27031                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27032                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27034                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27035         }
27036         if (flags & NDR_OUT) {
27037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27038         }
27039         return NDR_ERR_SUCCESS;
27040 }
27041
27042 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27043 {
27044         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27045         ndr->depth++;
27046         if (flags & NDR_SET_VALUES) {
27047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27048         }
27049         if (flags & NDR_IN) {
27050                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27051                 ndr->depth++;
27052                 ndr_print_ptr(ndr, "servername", r->in.servername);
27053                 ndr->depth++;
27054                 if (r->in.servername) {
27055                         ndr_print_string(ndr, "servername", r->in.servername);
27056                 }
27057                 ndr->depth--;
27058                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27059                 ndr->depth++;
27060                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27061                 ndr->depth--;
27062                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27063                 ndr->depth--;
27064         }
27065         if (flags & NDR_OUT) {
27066                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27067                 ndr->depth++;
27068                 ndr_print_WERROR(ndr, "result", r->out.result);
27069                 ndr->depth--;
27070         }
27071         ndr->depth--;
27072 }
27073
27074 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27075 {
27076         if (flags & NDR_IN) {
27077         }
27078         if (flags & NDR_OUT) {
27079                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27080         }
27081         return NDR_ERR_SUCCESS;
27082 }
27083
27084 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27085 {
27086         if (flags & NDR_IN) {
27087         }
27088         if (flags & NDR_OUT) {
27089                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27090         }
27091         return NDR_ERR_SUCCESS;
27092 }
27093
27094 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27095 {
27096         ndr_print_struct(ndr, name, "spoolss_5a");
27097         ndr->depth++;
27098         if (flags & NDR_SET_VALUES) {
27099                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27100         }
27101         if (flags & NDR_IN) {
27102                 ndr_print_struct(ndr, "in", "spoolss_5a");
27103                 ndr->depth++;
27104                 ndr->depth--;
27105         }
27106         if (flags & NDR_OUT) {
27107                 ndr_print_struct(ndr, "out", "spoolss_5a");
27108                 ndr->depth++;
27109                 ndr_print_WERROR(ndr, "result", r->out.result);
27110                 ndr->depth--;
27111         }
27112         ndr->depth--;
27113 }
27114
27115 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27116 {
27117         if (flags & NDR_IN) {
27118         }
27119         if (flags & NDR_OUT) {
27120                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27121         }
27122         return NDR_ERR_SUCCESS;
27123 }
27124
27125 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27126 {
27127         if (flags & NDR_IN) {
27128         }
27129         if (flags & NDR_OUT) {
27130                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27131         }
27132         return NDR_ERR_SUCCESS;
27133 }
27134
27135 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27136 {
27137         ndr_print_struct(ndr, name, "spoolss_5b");
27138         ndr->depth++;
27139         if (flags & NDR_SET_VALUES) {
27140                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27141         }
27142         if (flags & NDR_IN) {
27143                 ndr_print_struct(ndr, "in", "spoolss_5b");
27144                 ndr->depth++;
27145                 ndr->depth--;
27146         }
27147         if (flags & NDR_OUT) {
27148                 ndr_print_struct(ndr, "out", "spoolss_5b");
27149                 ndr->depth++;
27150                 ndr_print_WERROR(ndr, "result", r->out.result);
27151                 ndr->depth--;
27152         }
27153         ndr->depth--;
27154 }
27155
27156 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27157 {
27158         if (flags & NDR_IN) {
27159         }
27160         if (flags & NDR_OUT) {
27161                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27162         }
27163         return NDR_ERR_SUCCESS;
27164 }
27165
27166 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27167 {
27168         if (flags & NDR_IN) {
27169         }
27170         if (flags & NDR_OUT) {
27171                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27172         }
27173         return NDR_ERR_SUCCESS;
27174 }
27175
27176 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27177 {
27178         ndr_print_struct(ndr, name, "spoolss_5c");
27179         ndr->depth++;
27180         if (flags & NDR_SET_VALUES) {
27181                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27182         }
27183         if (flags & NDR_IN) {
27184                 ndr_print_struct(ndr, "in", "spoolss_5c");
27185                 ndr->depth++;
27186                 ndr->depth--;
27187         }
27188         if (flags & NDR_OUT) {
27189                 ndr_print_struct(ndr, "out", "spoolss_5c");
27190                 ndr->depth++;
27191                 ndr_print_WERROR(ndr, "result", r->out.result);
27192                 ndr->depth--;
27193         }
27194         ndr->depth--;
27195 }
27196
27197 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27198 {
27199         if (flags & NDR_IN) {
27200         }
27201         if (flags & NDR_OUT) {
27202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27203         }
27204         return NDR_ERR_SUCCESS;
27205 }
27206
27207 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27208 {
27209         if (flags & NDR_IN) {
27210         }
27211         if (flags & NDR_OUT) {
27212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27213         }
27214         return NDR_ERR_SUCCESS;
27215 }
27216
27217 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27218 {
27219         ndr_print_struct(ndr, name, "spoolss_5d");
27220         ndr->depth++;
27221         if (flags & NDR_SET_VALUES) {
27222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27223         }
27224         if (flags & NDR_IN) {
27225                 ndr_print_struct(ndr, "in", "spoolss_5d");
27226                 ndr->depth++;
27227                 ndr->depth--;
27228         }
27229         if (flags & NDR_OUT) {
27230                 ndr_print_struct(ndr, "out", "spoolss_5d");
27231                 ndr->depth++;
27232                 ndr_print_WERROR(ndr, "result", r->out.result);
27233                 ndr->depth--;
27234         }
27235         ndr->depth--;
27236 }
27237
27238 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27239 {
27240         if (flags & NDR_IN) {
27241         }
27242         if (flags & NDR_OUT) {
27243                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27244         }
27245         return NDR_ERR_SUCCESS;
27246 }
27247
27248 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27249 {
27250         if (flags & NDR_IN) {
27251         }
27252         if (flags & NDR_OUT) {
27253                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27254         }
27255         return NDR_ERR_SUCCESS;
27256 }
27257
27258 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27259 {
27260         ndr_print_struct(ndr, name, "spoolss_5e");
27261         ndr->depth++;
27262         if (flags & NDR_SET_VALUES) {
27263                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27264         }
27265         if (flags & NDR_IN) {
27266                 ndr_print_struct(ndr, "in", "spoolss_5e");
27267                 ndr->depth++;
27268                 ndr->depth--;
27269         }
27270         if (flags & NDR_OUT) {
27271                 ndr_print_struct(ndr, "out", "spoolss_5e");
27272                 ndr->depth++;
27273                 ndr_print_WERROR(ndr, "result", r->out.result);
27274                 ndr->depth--;
27275         }
27276         ndr->depth--;
27277 }
27278
27279 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27280 {
27281         if (flags & NDR_IN) {
27282         }
27283         if (flags & NDR_OUT) {
27284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27285         }
27286         return NDR_ERR_SUCCESS;
27287 }
27288
27289 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27290 {
27291         if (flags & NDR_IN) {
27292         }
27293         if (flags & NDR_OUT) {
27294                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27295         }
27296         return NDR_ERR_SUCCESS;
27297 }
27298
27299 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27300 {
27301         ndr_print_struct(ndr, name, "spoolss_5f");
27302         ndr->depth++;
27303         if (flags & NDR_SET_VALUES) {
27304                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27305         }
27306         if (flags & NDR_IN) {
27307                 ndr_print_struct(ndr, "in", "spoolss_5f");
27308                 ndr->depth++;
27309                 ndr->depth--;
27310         }
27311         if (flags & NDR_OUT) {
27312                 ndr_print_struct(ndr, "out", "spoolss_5f");
27313                 ndr->depth++;
27314                 ndr_print_WERROR(ndr, "result", r->out.result);
27315                 ndr->depth--;
27316         }
27317         ndr->depth--;
27318 }
27319
27320 static const struct ndr_interface_call spoolss_calls[] = {
27321         {
27322                 "spoolss_EnumPrinters",
27323                 sizeof(struct spoolss_EnumPrinters),
27324                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27326                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27327                 false,
27328         },
27329         {
27330                 "spoolss_OpenPrinter",
27331                 sizeof(struct spoolss_OpenPrinter),
27332                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27334                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27335                 false,
27336         },
27337         {
27338                 "spoolss_SetJob",
27339                 sizeof(struct spoolss_SetJob),
27340                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27342                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27343                 false,
27344         },
27345         {
27346                 "spoolss_GetJob",
27347                 sizeof(struct spoolss_GetJob),
27348                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27350                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27351                 false,
27352         },
27353         {
27354                 "spoolss_EnumJobs",
27355                 sizeof(struct spoolss_EnumJobs),
27356                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27358                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27359                 false,
27360         },
27361         {
27362                 "spoolss_AddPrinter",
27363                 sizeof(struct spoolss_AddPrinter),
27364                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27366                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27367                 false,
27368         },
27369         {
27370                 "spoolss_DeletePrinter",
27371                 sizeof(struct spoolss_DeletePrinter),
27372                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27374                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27375                 false,
27376         },
27377         {
27378                 "spoolss_SetPrinter",
27379                 sizeof(struct spoolss_SetPrinter),
27380                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27382                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27383                 false,
27384         },
27385         {
27386                 "spoolss_GetPrinter",
27387                 sizeof(struct spoolss_GetPrinter),
27388                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27390                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27391                 false,
27392         },
27393         {
27394                 "spoolss_AddPrinterDriver",
27395                 sizeof(struct spoolss_AddPrinterDriver),
27396                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27398                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27399                 false,
27400         },
27401         {
27402                 "spoolss_EnumPrinterDrivers",
27403                 sizeof(struct spoolss_EnumPrinterDrivers),
27404                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27406                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27407                 false,
27408         },
27409         {
27410                 "spoolss_GetPrinterDriver",
27411                 sizeof(struct spoolss_GetPrinterDriver),
27412                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27414                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27415                 false,
27416         },
27417         {
27418                 "spoolss_GetPrinterDriverDirectory",
27419                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27420                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27422                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27423                 false,
27424         },
27425         {
27426                 "spoolss_DeletePrinterDriver",
27427                 sizeof(struct spoolss_DeletePrinterDriver),
27428                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27430                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27431                 false,
27432         },
27433         {
27434                 "spoolss_AddPrintProcessor",
27435                 sizeof(struct spoolss_AddPrintProcessor),
27436                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27438                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27439                 false,
27440         },
27441         {
27442                 "spoolss_EnumPrintProcessors",
27443                 sizeof(struct spoolss_EnumPrintProcessors),
27444                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27446                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27447                 false,
27448         },
27449         {
27450                 "spoolss_GetPrintProcessorDirectory",
27451                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27452                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27454                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27455                 false,
27456         },
27457         {
27458                 "spoolss_StartDocPrinter",
27459                 sizeof(struct spoolss_StartDocPrinter),
27460                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27462                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27463                 false,
27464         },
27465         {
27466                 "spoolss_StartPagePrinter",
27467                 sizeof(struct spoolss_StartPagePrinter),
27468                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27470                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27471                 false,
27472         },
27473         {
27474                 "spoolss_WritePrinter",
27475                 sizeof(struct spoolss_WritePrinter),
27476                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27478                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27479                 false,
27480         },
27481         {
27482                 "spoolss_EndPagePrinter",
27483                 sizeof(struct spoolss_EndPagePrinter),
27484                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27486                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27487                 false,
27488         },
27489         {
27490                 "spoolss_AbortPrinter",
27491                 sizeof(struct spoolss_AbortPrinter),
27492                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27494                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27495                 false,
27496         },
27497         {
27498                 "spoolss_ReadPrinter",
27499                 sizeof(struct spoolss_ReadPrinter),
27500                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27502                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27503                 false,
27504         },
27505         {
27506                 "spoolss_EndDocPrinter",
27507                 sizeof(struct spoolss_EndDocPrinter),
27508                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27510                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27511                 false,
27512         },
27513         {
27514                 "spoolss_AddJob",
27515                 sizeof(struct spoolss_AddJob),
27516                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27518                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27519                 false,
27520         },
27521         {
27522                 "spoolss_ScheduleJob",
27523                 sizeof(struct spoolss_ScheduleJob),
27524                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27526                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27527                 false,
27528         },
27529         {
27530                 "spoolss_GetPrinterData",
27531                 sizeof(struct spoolss_GetPrinterData),
27532                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27534                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27535                 false,
27536         },
27537         {
27538                 "spoolss_SetPrinterData",
27539                 sizeof(struct spoolss_SetPrinterData),
27540                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27542                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27543                 false,
27544         },
27545         {
27546                 "spoolss_WaitForPrinterChange",
27547                 sizeof(struct spoolss_WaitForPrinterChange),
27548                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27550                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27551                 false,
27552         },
27553         {
27554                 "spoolss_ClosePrinter",
27555                 sizeof(struct spoolss_ClosePrinter),
27556                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27558                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27559                 false,
27560         },
27561         {
27562                 "spoolss_AddForm",
27563                 sizeof(struct spoolss_AddForm),
27564                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27566                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27567                 false,
27568         },
27569         {
27570                 "spoolss_DeleteForm",
27571                 sizeof(struct spoolss_DeleteForm),
27572                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27574                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27575                 false,
27576         },
27577         {
27578                 "spoolss_GetForm",
27579                 sizeof(struct spoolss_GetForm),
27580                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27582                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27583                 false,
27584         },
27585         {
27586                 "spoolss_SetForm",
27587                 sizeof(struct spoolss_SetForm),
27588                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27590                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27591                 false,
27592         },
27593         {
27594                 "spoolss_EnumForms",
27595                 sizeof(struct spoolss_EnumForms),
27596                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27598                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27599                 false,
27600         },
27601         {
27602                 "spoolss_EnumPorts",
27603                 sizeof(struct spoolss_EnumPorts),
27604                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27606                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27607                 false,
27608         },
27609         {
27610                 "spoolss_EnumMonitors",
27611                 sizeof(struct spoolss_EnumMonitors),
27612                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27614                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27615                 false,
27616         },
27617         {
27618                 "spoolss_AddPort",
27619                 sizeof(struct spoolss_AddPort),
27620                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27622                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27623                 false,
27624         },
27625         {
27626                 "spoolss_ConfigurePort",
27627                 sizeof(struct spoolss_ConfigurePort),
27628                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27630                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27631                 false,
27632         },
27633         {
27634                 "spoolss_DeletePort",
27635                 sizeof(struct spoolss_DeletePort),
27636                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27638                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27639                 false,
27640         },
27641         {
27642                 "spoolss_CreatePrinterIC",
27643                 sizeof(struct spoolss_CreatePrinterIC),
27644                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27646                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27647                 false,
27648         },
27649         {
27650                 "spoolss_PlayGDIScriptOnPrinterIC",
27651                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27652                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27654                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27655                 false,
27656         },
27657         {
27658                 "spoolss_DeletePrinterIC",
27659                 sizeof(struct spoolss_DeletePrinterIC),
27660                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27662                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27663                 false,
27664         },
27665         {
27666                 "spoolss_AddPrinterConnection",
27667                 sizeof(struct spoolss_AddPrinterConnection),
27668                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27670                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27671                 false,
27672         },
27673         {
27674                 "spoolss_DeletePrinterConnection",
27675                 sizeof(struct spoolss_DeletePrinterConnection),
27676                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27678                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27679                 false,
27680         },
27681         {
27682                 "spoolss_PrinterMessageBox",
27683                 sizeof(struct spoolss_PrinterMessageBox),
27684                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27686                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27687                 false,
27688         },
27689         {
27690                 "spoolss_AddMonitor",
27691                 sizeof(struct spoolss_AddMonitor),
27692                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27694                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27695                 false,
27696         },
27697         {
27698                 "spoolss_DeleteMonitor",
27699                 sizeof(struct spoolss_DeleteMonitor),
27700                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27702                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27703                 false,
27704         },
27705         {
27706                 "spoolss_DeletePrintProcessor",
27707                 sizeof(struct spoolss_DeletePrintProcessor),
27708                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27710                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27711                 false,
27712         },
27713         {
27714                 "spoolss_AddPrintProvidor",
27715                 sizeof(struct spoolss_AddPrintProvidor),
27716                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27718                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27719                 false,
27720         },
27721         {
27722                 "spoolss_DeletePrintProvidor",
27723                 sizeof(struct spoolss_DeletePrintProvidor),
27724                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27726                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27727                 false,
27728         },
27729         {
27730                 "spoolss_EnumPrintProcDataTypes",
27731                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27732                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27734                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27735                 false,
27736         },
27737         {
27738                 "spoolss_ResetPrinter",
27739                 sizeof(struct spoolss_ResetPrinter),
27740                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27742                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27743                 false,
27744         },
27745         {
27746                 "spoolss_GetPrinterDriver2",
27747                 sizeof(struct spoolss_GetPrinterDriver2),
27748                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27750                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27751                 false,
27752         },
27753         {
27754                 "spoolss_FindFirstPrinterChangeNotification",
27755                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27756                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27758                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27759                 false,
27760         },
27761         {
27762                 "spoolss_FindNextPrinterChangeNotification",
27763                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27764                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27766                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27767                 false,
27768         },
27769         {
27770                 "spoolss_FindClosePrinterNotify",
27771                 sizeof(struct spoolss_FindClosePrinterNotify),
27772                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27774                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27775                 false,
27776         },
27777         {
27778                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27779                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27780                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27782                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27783                 false,
27784         },
27785         {
27786                 "spoolss_ReplyOpenPrinter",
27787                 sizeof(struct spoolss_ReplyOpenPrinter),
27788                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27790                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27791                 false,
27792         },
27793         {
27794                 "spoolss_RouterReplyPrinter",
27795                 sizeof(struct spoolss_RouterReplyPrinter),
27796                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27798                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27799                 false,
27800         },
27801         {
27802                 "spoolss_ReplyClosePrinter",
27803                 sizeof(struct spoolss_ReplyClosePrinter),
27804                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27806                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27807                 false,
27808         },
27809         {
27810                 "spoolss_AddPortEx",
27811                 sizeof(struct spoolss_AddPortEx),
27812                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27814                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27815                 false,
27816         },
27817         {
27818                 "spoolss_RouterFindFirstPrinterChangeNotification",
27819                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27820                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27822                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27823                 false,
27824         },
27825         {
27826                 "spoolss_SpoolerInit",
27827                 sizeof(struct spoolss_SpoolerInit),
27828                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27830                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27831                 false,
27832         },
27833         {
27834                 "spoolss_ResetPrinterEx",
27835                 sizeof(struct spoolss_ResetPrinterEx),
27836                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27838                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27839                 false,
27840         },
27841         {
27842                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27843                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27844                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27846                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27847                 false,
27848         },
27849         {
27850                 "spoolss_RouterReplyPrinterEx",
27851                 sizeof(struct spoolss_RouterReplyPrinterEx),
27852                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27854                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27855                 false,
27856         },
27857         {
27858                 "spoolss_RouterRefreshPrinterChangeNotify",
27859                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27860                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27862                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27863                 false,
27864         },
27865         {
27866                 "spoolss_44",
27867                 sizeof(struct spoolss_44),
27868                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27870                 (ndr_print_function_t) ndr_print_spoolss_44,
27871                 false,
27872         },
27873         {
27874                 "spoolss_OpenPrinterEx",
27875                 sizeof(struct spoolss_OpenPrinterEx),
27876                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27878                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27879                 false,
27880         },
27881         {
27882                 "spoolss_AddPrinterEx",
27883                 sizeof(struct spoolss_AddPrinterEx),
27884                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27886                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27887                 false,
27888         },
27889         {
27890                 "spoolss_47",
27891                 sizeof(struct spoolss_47),
27892                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27894                 (ndr_print_function_t) ndr_print_spoolss_47,
27895                 false,
27896         },
27897         {
27898                 "spoolss_EnumPrinterData",
27899                 sizeof(struct spoolss_EnumPrinterData),
27900                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27902                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27903                 false,
27904         },
27905         {
27906                 "spoolss_DeletePrinterData",
27907                 sizeof(struct spoolss_DeletePrinterData),
27908                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27910                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27911                 false,
27912         },
27913         {
27914                 "spoolss_4a",
27915                 sizeof(struct spoolss_4a),
27916                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27918                 (ndr_print_function_t) ndr_print_spoolss_4a,
27919                 false,
27920         },
27921         {
27922                 "spoolss_4b",
27923                 sizeof(struct spoolss_4b),
27924                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27926                 (ndr_print_function_t) ndr_print_spoolss_4b,
27927                 false,
27928         },
27929         {
27930                 "spoolss_4c",
27931                 sizeof(struct spoolss_4c),
27932                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27934                 (ndr_print_function_t) ndr_print_spoolss_4c,
27935                 false,
27936         },
27937         {
27938                 "spoolss_SetPrinterDataEx",
27939                 sizeof(struct spoolss_SetPrinterDataEx),
27940                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27942                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27943                 false,
27944         },
27945         {
27946                 "spoolss_GetPrinterDataEx",
27947                 sizeof(struct spoolss_GetPrinterDataEx),
27948                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27950                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27951                 false,
27952         },
27953         {
27954                 "spoolss_EnumPrinterDataEx",
27955                 sizeof(struct spoolss_EnumPrinterDataEx),
27956                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27958                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27959                 false,
27960         },
27961         {
27962                 "spoolss_EnumPrinterKey",
27963                 sizeof(struct spoolss_EnumPrinterKey),
27964                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27966                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27967                 false,
27968         },
27969         {
27970                 "spoolss_DeletePrinterDataEx",
27971                 sizeof(struct spoolss_DeletePrinterDataEx),
27972                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27974                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27975                 false,
27976         },
27977         {
27978                 "spoolss_DeletePrinterKey",
27979                 sizeof(struct spoolss_DeletePrinterKey),
27980                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27982                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27983                 false,
27984         },
27985         {
27986                 "spoolss_53",
27987                 sizeof(struct spoolss_53),
27988                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27990                 (ndr_print_function_t) ndr_print_spoolss_53,
27991                 false,
27992         },
27993         {
27994                 "spoolss_DeletePrinterDriverEx",
27995                 sizeof(struct spoolss_DeletePrinterDriverEx),
27996                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27998                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27999                 false,
28000         },
28001         {
28002                 "spoolss_55",
28003                 sizeof(struct spoolss_55),
28004                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28006                 (ndr_print_function_t) ndr_print_spoolss_55,
28007                 false,
28008         },
28009         {
28010                 "spoolss_56",
28011                 sizeof(struct spoolss_56),
28012                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28014                 (ndr_print_function_t) ndr_print_spoolss_56,
28015                 false,
28016         },
28017         {
28018                 "spoolss_57",
28019                 sizeof(struct spoolss_57),
28020                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28022                 (ndr_print_function_t) ndr_print_spoolss_57,
28023                 false,
28024         },
28025         {
28026                 "spoolss_XcvData",
28027                 sizeof(struct spoolss_XcvData),
28028                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28030                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28031                 false,
28032         },
28033         {
28034                 "spoolss_AddPrinterDriverEx",
28035                 sizeof(struct spoolss_AddPrinterDriverEx),
28036                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28038                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28039                 false,
28040         },
28041         {
28042                 "spoolss_5a",
28043                 sizeof(struct spoolss_5a),
28044                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28046                 (ndr_print_function_t) ndr_print_spoolss_5a,
28047                 false,
28048         },
28049         {
28050                 "spoolss_5b",
28051                 sizeof(struct spoolss_5b),
28052                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28054                 (ndr_print_function_t) ndr_print_spoolss_5b,
28055                 false,
28056         },
28057         {
28058                 "spoolss_5c",
28059                 sizeof(struct spoolss_5c),
28060                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28062                 (ndr_print_function_t) ndr_print_spoolss_5c,
28063                 false,
28064         },
28065         {
28066                 "spoolss_5d",
28067                 sizeof(struct spoolss_5d),
28068                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28070                 (ndr_print_function_t) ndr_print_spoolss_5d,
28071                 false,
28072         },
28073         {
28074                 "spoolss_5e",
28075                 sizeof(struct spoolss_5e),
28076                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28078                 (ndr_print_function_t) ndr_print_spoolss_5e,
28079                 false,
28080         },
28081         {
28082                 "spoolss_5f",
28083                 sizeof(struct spoolss_5f),
28084                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28086                 (ndr_print_function_t) ndr_print_spoolss_5f,
28087                 false,
28088         },
28089         { NULL, 0, NULL, NULL, NULL, false }
28090 };
28091
28092 static const char * const spoolss_endpoint_strings[] = {
28093         "ncacn_np:[\\pipe\\spoolss]",
28094 };
28095
28096 static const struct ndr_interface_string_array spoolss_endpoints = {
28097         .count  = 1,
28098         .names  = spoolss_endpoint_strings
28099 };
28100
28101 static const char * const spoolss_authservice_strings[] = {
28102         "host",
28103 };
28104
28105 static const struct ndr_interface_string_array spoolss_authservices = {
28106         .count  = 1,
28107         .names  = spoolss_authservice_strings
28108 };
28109
28110
28111 const struct ndr_interface_table ndr_table_spoolss = {
28112         .name           = "spoolss",
28113         .syntax_id      = {
28114                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28115                 NDR_SPOOLSS_VERSION
28116         },
28117         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28118         .num_calls      = 96,
28119         .calls          = spoolss_calls,
28120         .endpoints      = &spoolss_endpoints,
28121         .authservices   = &spoolss_authservices
28122 };
28123