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 static 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 static 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 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 516 {
 517         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 518         return NDR_ERR_SUCCESS;
 519 }
 520
 521 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 522 {
 523         uint32_t v;
 524         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 525         *r = v;
 526         return NDR_ERR_SUCCESS;
 527 }
 528
 529 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 530 {
 531         ndr_print_uint32(ndr, name, r);
 532         ndr->depth++;
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 561         ndr->depth--;
 562 }
 563
 564 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 565 {
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_push_align(ndr, 4));
 568                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 569                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 570                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 571                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 572                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 573                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 578                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 587                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 602                 {
 603                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 605                         {
 606                                 struct ndr_push *_ndr_driverextra_data;
 607                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 608                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 609                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 610                         }
 611                         ndr->flags = _flags_save_DATA_BLOB;
 612                 }
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615         }
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 620 {
 621         if (ndr_flags & NDR_SCALARS) {
 622                 NDR_CHECK(ndr_pull_align(ndr, 4));
 623                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 624                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 625                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 626                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 627                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 628                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 633                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 642                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 657                 {
 658                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 660                         {
 661                                 struct ndr_pull *_ndr_driverextra_data;
 662                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 663                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 664                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 665                         }
 666                         ndr->flags = _flags_save_DATA_BLOB;
 667                 }
 668         }
 669         if (ndr_flags & NDR_BUFFERS) {
 670         }
 671         return NDR_ERR_SUCCESS;
 672 }
 673
 674 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 675 {
 676         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 677         ndr->depth++;
 678         ndr_print_string(ndr, "devicename", r->devicename);
 679         ndr_print_uint16(ndr, "specversion", r->specversion);
 680         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 681         ndr_print_uint16(ndr, "size", r->size);
 682         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 683         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 684         ndr_print_uint16(ndr, "orientation", r->orientation);
 685         ndr_print_uint16(ndr, "papersize", r->papersize);
 686         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 687         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 688         ndr_print_uint16(ndr, "scale", r->scale);
 689         ndr_print_uint16(ndr, "copies", r->copies);
 690         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 691         ndr_print_uint16(ndr, "printquality", r->printquality);
 692         ndr_print_uint16(ndr, "color", r->color);
 693         ndr_print_uint16(ndr, "duplex", r->duplex);
 694         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 695         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 696         ndr_print_uint16(ndr, "collate", r->collate);
 697         ndr_print_string(ndr, "formname", r->formname);
 698         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 699         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 700         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 701         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 702         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 703         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 704         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 705         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 706         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 707         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 708         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 709         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 710         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 711         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 712         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 713         ndr->depth--;
 714 }
 715
 716 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 717 {
 718         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 719 }
 720
 721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 722 {
 723         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 724         return NDR_ERR_SUCCESS;
 725 }
 726
 727 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 728 {
 729         uint32_t v;
 730         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 731         *r = v;
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 736 {
 737         ndr_print_uint32(ndr, name, r);
 738         ndr->depth++;
 739         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 758         ndr->depth--;
 759 }
 760
 761 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 762 {
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_push_align(ndr, 4));
 765                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 766                 {
 767                         uint32_t _flags_save_string = ndr->flags;
 768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 776                         ndr->flags = _flags_save_string;
 777                 }
 778                 {
 779                         uint32_t _flags_save_string = ndr->flags;
 780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 792                         }
 793                         ndr->flags = _flags_save_string;
 794                 }
 795                 {
 796                         uint32_t _flags_save_string = ndr->flags;
 797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 798                         if (r->description) {
 799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 801                         }
 802                         ndr->flags = _flags_save_string;
 803                 }
 804                 {
 805                         uint32_t _flags_save_string = ndr->flags;
 806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 807                         if (r->comment) {
 808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 810                         }
 811                         ndr->flags = _flags_save_string;
 812                 }
 813         }
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 818 {
 819         uint32_t _ptr_name;
 820         TALLOC_CTX *_mem_save_name_0;
 821         uint32_t _ptr_description;
 822         TALLOC_CTX *_mem_save_description_0;
 823         uint32_t _ptr_comment;
 824         TALLOC_CTX *_mem_save_comment_0;
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 4));
 827                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 828                 {
 829                         uint32_t _flags_save_string = ndr->flags;
 830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 832                         if (_ptr_name) {
 833                                 NDR_PULL_ALLOC(ndr, r->name);
 834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 835                         } else {
 836                                 r->name = NULL;
 837                         }
 838                         ndr->flags = _flags_save_string;
 839                 }
 840                 {
 841                         uint32_t _flags_save_string = ndr->flags;
 842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 844                         if (_ptr_description) {
 845                                 NDR_PULL_ALLOC(ndr, r->description);
 846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 847                         } else {
 848                                 r->description = NULL;
 849                         }
 850                         ndr->flags = _flags_save_string;
 851                 }
 852                 {
 853                         uint32_t _flags_save_string = ndr->flags;
 854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 856                         if (_ptr_comment) {
 857                                 NDR_PULL_ALLOC(ndr, r->comment);
 858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 859                         } else {
 860                                 r->comment = NULL;
 861                         }
 862                         ndr->flags = _flags_save_string;
 863                 }
 864         }
 865         if (ndr_flags & NDR_BUFFERS) {
 866                 {
 867                         uint32_t _flags_save_string = ndr->flags;
 868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 869                         if (r->name) {
 870                                 uint32_t _relative_save_offset;
 871                                 _relative_save_offset = ndr->offset;
 872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 873                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 874                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 877                                 ndr->offset = _relative_save_offset;
 878                         }
 879                         ndr->flags = _flags_save_string;
 880                 }
 881                 {
 882                         uint32_t _flags_save_string = ndr->flags;
 883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 884                         if (r->description) {
 885                                 uint32_t _relative_save_offset;
 886                                 _relative_save_offset = ndr->offset;
 887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 888                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 889                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 892                                 ndr->offset = _relative_save_offset;
 893                         }
 894                         ndr->flags = _flags_save_string;
 895                 }
 896                 {
 897                         uint32_t _flags_save_string = ndr->flags;
 898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 899                         if (r->comment) {
 900                                 uint32_t _relative_save_offset;
 901                                 _relative_save_offset = ndr->offset;
 902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 903                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 907                                 ndr->offset = _relative_save_offset;
 908                         }
 909                         ndr->flags = _flags_save_string;
 910                 }
 911         }
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 916 {
 917         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 918         ndr->depth++;
 919         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 920         ndr_print_ptr(ndr, "name", r->name);
 921         ndr->depth++;
 922         if (r->name) {
 923                 ndr_print_string(ndr, "name", r->name);
 924         }
 925         ndr->depth--;
 926         ndr_print_ptr(ndr, "description", r->description);
 927         ndr->depth++;
 928         if (r->description) {
 929                 ndr_print_string(ndr, "description", r->description);
 930         }
 931         ndr->depth--;
 932         ndr_print_ptr(ndr, "comment", r->comment);
 933         ndr->depth++;
 934         if (r->comment) {
 935                 ndr_print_string(ndr, "comment", r->comment);
 936         }
 937         ndr->depth--;
 938         ndr->depth--;
 939 }
 940
 941 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 942 {
 943         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 944         return NDR_ERR_SUCCESS;
 945 }
 946
 947 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 948 {
 949         uint32_t v;
 950         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 951         *r = v;
 952         return NDR_ERR_SUCCESS;
 953 }
 954
 955 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 956 {
 957         ndr_print_uint32(ndr, name, r);
 958         ndr->depth++;
 959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 975         ndr->depth--;
 976 }
 977
 978 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 979 {
 980         if (ndr_flags & NDR_SCALARS) {
 981                 NDR_CHECK(ndr_push_align(ndr, 4));
 982                 {
 983                         uint32_t _flags_save_string = ndr->flags;
 984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 985                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 986                         ndr->flags = _flags_save_string;
 987                 }
 988                 {
 989                         uint32_t _flags_save_string = ndr->flags;
 990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 991                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 992                         ndr->flags = _flags_save_string;
 993                 }
 994                 {
 995                         uint32_t _flags_save_string = ndr->flags;
 996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 997                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 998                         ndr->flags = _flags_save_string;
 999                 }
1000                 {
1001                         uint32_t _flags_save_string = ndr->flags;
1002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1003                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1004                         ndr->flags = _flags_save_string;
1005                 }
1006                 {
1007                         uint32_t _flags_save_string = ndr->flags;
1008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1009                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1010                         ndr->flags = _flags_save_string;
1011                 }
1012                 {
1013                         uint32_t _flags_save_string = ndr->flags;
1014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1015                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1016                         ndr->flags = _flags_save_string;
1017                 }
1018                 {
1019                         uint32_t _flags_save_string = ndr->flags;
1020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1022                         ndr->flags = _flags_save_string;
1023                 }
1024                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1025                 {
1026                         uint32_t _flags_save_string = ndr->flags;
1027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1028                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1029                         ndr->flags = _flags_save_string;
1030                 }
1031                 {
1032                         uint32_t _flags_save_string = ndr->flags;
1033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1034                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1035                         ndr->flags = _flags_save_string;
1036                 }
1037                 {
1038                         uint32_t _flags_save_string = ndr->flags;
1039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1040                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1041                         ndr->flags = _flags_save_string;
1042                 }
1043                 {
1044                         uint32_t _flags_save_string = ndr->flags;
1045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1047                         ndr->flags = _flags_save_string;
1048                 }
1049                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1050                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1055                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1058         }
1059         if (ndr_flags & NDR_BUFFERS) {
1060                 {
1061                         uint32_t _flags_save_string = ndr->flags;
1062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1063                         if (r->servername) {
1064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1066                         }
1067                         ndr->flags = _flags_save_string;
1068                 }
1069                 {
1070                         uint32_t _flags_save_string = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1072                         if (r->printername) {
1073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1075                         }
1076                         ndr->flags = _flags_save_string;
1077                 }
1078                 {
1079                         uint32_t _flags_save_string = ndr->flags;
1080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1081                         if (r->sharename) {
1082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1084                         }
1085                         ndr->flags = _flags_save_string;
1086                 }
1087                 {
1088                         uint32_t _flags_save_string = ndr->flags;
1089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1090                         if (r->portname) {
1091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1093                         }
1094                         ndr->flags = _flags_save_string;
1095                 }
1096                 {
1097                         uint32_t _flags_save_string = ndr->flags;
1098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1099                         if (r->drivername) {
1100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1102                         }
1103                         ndr->flags = _flags_save_string;
1104                 }
1105                 {
1106                         uint32_t _flags_save_string = ndr->flags;
1107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1108                         if (r->comment) {
1109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1111                         }
1112                         ndr->flags = _flags_save_string;
1113                 }
1114                 {
1115                         uint32_t _flags_save_string = ndr->flags;
1116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1117                         if (r->location) {
1118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1119                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1120                         }
1121                         ndr->flags = _flags_save_string;
1122                 }
1123                 if (r->devmode) {
1124                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1125                         {
1126                                 struct ndr_push *_ndr_devmode;
1127                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1128                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1129                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1130                         }
1131                 }
1132                 {
1133                         uint32_t _flags_save_string = ndr->flags;
1134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1135                         if (r->sepfile) {
1136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1138                         }
1139                         ndr->flags = _flags_save_string;
1140                 }
1141                 {
1142                         uint32_t _flags_save_string = ndr->flags;
1143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1144                         if (r->printprocessor) {
1145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1147                         }
1148                         ndr->flags = _flags_save_string;
1149                 }
1150                 {
1151                         uint32_t _flags_save_string = ndr->flags;
1152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1153                         if (r->datatype) {
1154                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1155                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1156                         }
1157                         ndr->flags = _flags_save_string;
1158                 }
1159                 {
1160                         uint32_t _flags_save_string = ndr->flags;
1161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1162                         if (r->parameters) {
1163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1165                         }
1166                         ndr->flags = _flags_save_string;
1167                 }
1168                 if (r->secdesc) {
1169                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1170                         {
1171                                 struct ndr_push *_ndr_secdesc;
1172                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1173                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1174                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1175                         }
1176                 }
1177         }
1178         return NDR_ERR_SUCCESS;
1179 }
1180
1181 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1182 {
1183         uint32_t _ptr_servername;
1184         TALLOC_CTX *_mem_save_servername_0;
1185         uint32_t _ptr_printername;
1186         TALLOC_CTX *_mem_save_printername_0;
1187         uint32_t _ptr_sharename;
1188         TALLOC_CTX *_mem_save_sharename_0;
1189         uint32_t _ptr_portname;
1190         TALLOC_CTX *_mem_save_portname_0;
1191         uint32_t _ptr_drivername;
1192         TALLOC_CTX *_mem_save_drivername_0;
1193         uint32_t _ptr_comment;
1194         TALLOC_CTX *_mem_save_comment_0;
1195         uint32_t _ptr_location;
1196         TALLOC_CTX *_mem_save_location_0;
1197         uint32_t _ptr_devmode;
1198         TALLOC_CTX *_mem_save_devmode_0;
1199         uint32_t _ptr_sepfile;
1200         TALLOC_CTX *_mem_save_sepfile_0;
1201         uint32_t _ptr_printprocessor;
1202         TALLOC_CTX *_mem_save_printprocessor_0;
1203         uint32_t _ptr_datatype;
1204         TALLOC_CTX *_mem_save_datatype_0;
1205         uint32_t _ptr_parameters;
1206         TALLOC_CTX *_mem_save_parameters_0;
1207         uint32_t _ptr_secdesc;
1208         TALLOC_CTX *_mem_save_secdesc_0;
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 4));
1211                 {
1212                         uint32_t _flags_save_string = ndr->flags;
1213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1215                         if (_ptr_servername) {
1216                                 NDR_PULL_ALLOC(ndr, r->servername);
1217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1218                         } else {
1219                                 r->servername = NULL;
1220                         }
1221                         ndr->flags = _flags_save_string;
1222                 }
1223                 {
1224                         uint32_t _flags_save_string = ndr->flags;
1225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1226                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1227                         if (_ptr_printername) {
1228                                 NDR_PULL_ALLOC(ndr, r->printername);
1229                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1230                         } else {
1231                                 r->printername = NULL;
1232                         }
1233                         ndr->flags = _flags_save_string;
1234                 }
1235                 {
1236                         uint32_t _flags_save_string = ndr->flags;
1237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1239                         if (_ptr_sharename) {
1240                                 NDR_PULL_ALLOC(ndr, r->sharename);
1241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1242                         } else {
1243                                 r->sharename = NULL;
1244                         }
1245                         ndr->flags = _flags_save_string;
1246                 }
1247                 {
1248                         uint32_t _flags_save_string = ndr->flags;
1249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1250                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1251                         if (_ptr_portname) {
1252                                 NDR_PULL_ALLOC(ndr, r->portname);
1253                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1254                         } else {
1255                                 r->portname = NULL;
1256                         }
1257                         ndr->flags = _flags_save_string;
1258                 }
1259                 {
1260                         uint32_t _flags_save_string = ndr->flags;
1261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1262                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1263                         if (_ptr_drivername) {
1264                                 NDR_PULL_ALLOC(ndr, r->drivername);
1265                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1266                         } else {
1267                                 r->drivername = NULL;
1268                         }
1269                         ndr->flags = _flags_save_string;
1270                 }
1271                 {
1272                         uint32_t _flags_save_string = ndr->flags;
1273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1274                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1275                         if (_ptr_comment) {
1276                                 NDR_PULL_ALLOC(ndr, r->comment);
1277                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1278                         } else {
1279                                 r->comment = NULL;
1280                         }
1281                         ndr->flags = _flags_save_string;
1282                 }
1283                 {
1284                         uint32_t _flags_save_string = ndr->flags;
1285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1287                         if (_ptr_location) {
1288                                 NDR_PULL_ALLOC(ndr, r->location);
1289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1290                         } else {
1291                                 r->location = NULL;
1292                         }
1293                         ndr->flags = _flags_save_string;
1294                 }
1295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1296                 if (_ptr_devmode) {
1297                         NDR_PULL_ALLOC(ndr, r->devmode);
1298                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1299                 } else {
1300                         r->devmode = NULL;
1301                 }
1302                 {
1303                         uint32_t _flags_save_string = ndr->flags;
1304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1306                         if (_ptr_sepfile) {
1307                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1309                         } else {
1310                                 r->sepfile = NULL;
1311                         }
1312                         ndr->flags = _flags_save_string;
1313                 }
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1318                         if (_ptr_printprocessor) {
1319                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1321                         } else {
1322                                 r->printprocessor = NULL;
1323                         }
1324                         ndr->flags = _flags_save_string;
1325                 }
1326                 {
1327                         uint32_t _flags_save_string = ndr->flags;
1328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1330                         if (_ptr_datatype) {
1331                                 NDR_PULL_ALLOC(ndr, r->datatype);
1332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1333                         } else {
1334                                 r->datatype = NULL;
1335                         }
1336                         ndr->flags = _flags_save_string;
1337                 }
1338                 {
1339                         uint32_t _flags_save_string = ndr->flags;
1340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1342                         if (_ptr_parameters) {
1343                                 NDR_PULL_ALLOC(ndr, r->parameters);
1344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1345                         } else {
1346                                 r->parameters = NULL;
1347                         }
1348                         ndr->flags = _flags_save_string;
1349                 }
1350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1351                 if (_ptr_secdesc) {
1352                         NDR_PULL_ALLOC(ndr, r->secdesc);
1353                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1354                 } else {
1355                         r->secdesc = NULL;
1356                 }
1357                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1362                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1365         }
1366         if (ndr_flags & NDR_BUFFERS) {
1367                 {
1368                         uint32_t _flags_save_string = ndr->flags;
1369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1370                         if (r->servername) {
1371                                 uint32_t _relative_save_offset;
1372                                 _relative_save_offset = ndr->offset;
1373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1374                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1375                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1378                                 ndr->offset = _relative_save_offset;
1379                         }
1380                         ndr->flags = _flags_save_string;
1381                 }
1382                 {
1383                         uint32_t _flags_save_string = ndr->flags;
1384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1385                         if (r->printername) {
1386                                 uint32_t _relative_save_offset;
1387                                 _relative_save_offset = ndr->offset;
1388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1389                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1390                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1393                                 ndr->offset = _relative_save_offset;
1394                         }
1395                         ndr->flags = _flags_save_string;
1396                 }
1397                 {
1398                         uint32_t _flags_save_string = ndr->flags;
1399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1400                         if (r->sharename) {
1401                                 uint32_t _relative_save_offset;
1402                                 _relative_save_offset = ndr->offset;
1403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1404                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1405                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1406                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1408                                 ndr->offset = _relative_save_offset;
1409                         }
1410                         ndr->flags = _flags_save_string;
1411                 }
1412                 {
1413                         uint32_t _flags_save_string = ndr->flags;
1414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1415                         if (r->portname) {
1416                                 uint32_t _relative_save_offset;
1417                                 _relative_save_offset = ndr->offset;
1418                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1419                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1420                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1421                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1422                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1423                                 ndr->offset = _relative_save_offset;
1424                         }
1425                         ndr->flags = _flags_save_string;
1426                 }
1427                 {
1428                         uint32_t _flags_save_string = ndr->flags;
1429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1430                         if (r->drivername) {
1431                                 uint32_t _relative_save_offset;
1432                                 _relative_save_offset = ndr->offset;
1433                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1434                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1435                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1436                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1437                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1438                                 ndr->offset = _relative_save_offset;
1439                         }
1440                         ndr->flags = _flags_save_string;
1441                 }
1442                 {
1443                         uint32_t _flags_save_string = ndr->flags;
1444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1445                         if (r->comment) {
1446                                 uint32_t _relative_save_offset;
1447                                 _relative_save_offset = ndr->offset;
1448                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1449                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1450                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1451                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1452                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1453                                 ndr->offset = _relative_save_offset;
1454                         }
1455                         ndr->flags = _flags_save_string;
1456                 }
1457                 {
1458                         uint32_t _flags_save_string = ndr->flags;
1459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1460                         if (r->location) {
1461                                 uint32_t _relative_save_offset;
1462                                 _relative_save_offset = ndr->offset;
1463                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1464                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1465                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1466                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1467                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1468                                 ndr->offset = _relative_save_offset;
1469                         }
1470                         ndr->flags = _flags_save_string;
1471                 }
1472                 if (r->devmode) {
1473                         uint32_t _relative_save_offset;
1474                         _relative_save_offset = ndr->offset;
1475                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1476                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1477                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1478                         {
1479                                 struct ndr_pull *_ndr_devmode;
1480                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1481                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1482                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1483                         }
1484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1485                         ndr->offset = _relative_save_offset;
1486                 }
1487                 {
1488                         uint32_t _flags_save_string = ndr->flags;
1489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1490                         if (r->sepfile) {
1491                                 uint32_t _relative_save_offset;
1492                                 _relative_save_offset = ndr->offset;
1493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1494                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1495                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1498                                 ndr->offset = _relative_save_offset;
1499                         }
1500                         ndr->flags = _flags_save_string;
1501                 }
1502                 {
1503                         uint32_t _flags_save_string = ndr->flags;
1504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1505                         if (r->printprocessor) {
1506                                 uint32_t _relative_save_offset;
1507                                 _relative_save_offset = ndr->offset;
1508                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1509                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1510                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1511                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1512                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1513                                 ndr->offset = _relative_save_offset;
1514                         }
1515                         ndr->flags = _flags_save_string;
1516                 }
1517                 {
1518                         uint32_t _flags_save_string = ndr->flags;
1519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1520                         if (r->datatype) {
1521                                 uint32_t _relative_save_offset;
1522                                 _relative_save_offset = ndr->offset;
1523                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1524                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1526                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1527                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1528                                 ndr->offset = _relative_save_offset;
1529                         }
1530                         ndr->flags = _flags_save_string;
1531                 }
1532                 {
1533                         uint32_t _flags_save_string = ndr->flags;
1534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1535                         if (r->parameters) {
1536                                 uint32_t _relative_save_offset;
1537                                 _relative_save_offset = ndr->offset;
1538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1539                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1540                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1543                                 ndr->offset = _relative_save_offset;
1544                         }
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 if (r->secdesc) {
1548                         uint32_t _relative_save_offset;
1549                         _relative_save_offset = ndr->offset;
1550                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1551                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1552                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1553                         {
1554                                 struct ndr_pull *_ndr_secdesc;
1555                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1556                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1557                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1558                         }
1559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1560                         ndr->offset = _relative_save_offset;
1561                 }
1562         }
1563         return NDR_ERR_SUCCESS;
1564 }
1565
1566 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1567 {
1568         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1569         ndr->depth++;
1570         ndr_print_ptr(ndr, "servername", r->servername);
1571         ndr->depth++;
1572         if (r->servername) {
1573                 ndr_print_string(ndr, "servername", r->servername);
1574         }
1575         ndr->depth--;
1576         ndr_print_ptr(ndr, "printername", r->printername);
1577         ndr->depth++;
1578         if (r->printername) {
1579                 ndr_print_string(ndr, "printername", r->printername);
1580         }
1581         ndr->depth--;
1582         ndr_print_ptr(ndr, "sharename", r->sharename);
1583         ndr->depth++;
1584         if (r->sharename) {
1585                 ndr_print_string(ndr, "sharename", r->sharename);
1586         }
1587         ndr->depth--;
1588         ndr_print_ptr(ndr, "portname", r->portname);
1589         ndr->depth++;
1590         if (r->portname) {
1591                 ndr_print_string(ndr, "portname", r->portname);
1592         }
1593         ndr->depth--;
1594         ndr_print_ptr(ndr, "drivername", r->drivername);
1595         ndr->depth++;
1596         if (r->drivername) {
1597                 ndr_print_string(ndr, "drivername", r->drivername);
1598         }
1599         ndr->depth--;
1600         ndr_print_ptr(ndr, "comment", r->comment);
1601         ndr->depth++;
1602         if (r->comment) {
1603                 ndr_print_string(ndr, "comment", r->comment);
1604         }
1605         ndr->depth--;
1606         ndr_print_ptr(ndr, "location", r->location);
1607         ndr->depth++;
1608         if (r->location) {
1609                 ndr_print_string(ndr, "location", r->location);
1610         }
1611         ndr->depth--;
1612         ndr_print_ptr(ndr, "devmode", r->devmode);
1613         ndr->depth++;
1614         if (r->devmode) {
1615                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1616         }
1617         ndr->depth--;
1618         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1619         ndr->depth++;
1620         if (r->sepfile) {
1621                 ndr_print_string(ndr, "sepfile", r->sepfile);
1622         }
1623         ndr->depth--;
1624         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1625         ndr->depth++;
1626         if (r->printprocessor) {
1627                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1628         }
1629         ndr->depth--;
1630         ndr_print_ptr(ndr, "datatype", r->datatype);
1631         ndr->depth++;
1632         if (r->datatype) {
1633                 ndr_print_string(ndr, "datatype", r->datatype);
1634         }
1635         ndr->depth--;
1636         ndr_print_ptr(ndr, "parameters", r->parameters);
1637         ndr->depth++;
1638         if (r->parameters) {
1639                 ndr_print_string(ndr, "parameters", r->parameters);
1640         }
1641         ndr->depth--;
1642         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1643         ndr->depth++;
1644         if (r->secdesc) {
1645                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1646         }
1647         ndr->depth--;
1648         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1649         ndr_print_uint32(ndr, "priority", r->priority);
1650         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1651         ndr_print_uint32(ndr, "starttime", r->starttime);
1652         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1653         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1654         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1655         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1656         ndr->depth--;
1657 }
1658
1659 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1660 {
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_push_align(ndr, 4));
1663                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1664         }
1665         if (ndr_flags & NDR_BUFFERS) {
1666                 if (r->secdesc) {
1667                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1668                         {
1669                                 struct ndr_push *_ndr_secdesc;
1670                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1671                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1672                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1673                         }
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1680 {
1681         uint32_t _ptr_secdesc;
1682         TALLOC_CTX *_mem_save_secdesc_0;
1683         if (ndr_flags & NDR_SCALARS) {
1684                 NDR_CHECK(ndr_pull_align(ndr, 4));
1685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1686                 if (_ptr_secdesc) {
1687                         NDR_PULL_ALLOC(ndr, r->secdesc);
1688                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1689                 } else {
1690                         r->secdesc = NULL;
1691                 }
1692         }
1693         if (ndr_flags & NDR_BUFFERS) {
1694                 if (r->secdesc) {
1695                         uint32_t _relative_save_offset;
1696                         _relative_save_offset = ndr->offset;
1697                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1698                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1700                         {
1701                                 struct ndr_pull *_ndr_secdesc;
1702                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1703                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1704                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1705                         }
1706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1707                         ndr->offset = _relative_save_offset;
1708                 }
1709         }
1710         return NDR_ERR_SUCCESS;
1711 }
1712
1713 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1714 {
1715         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1716         ndr->depth++;
1717         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1718         ndr->depth++;
1719         if (r->secdesc) {
1720                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1721         }
1722         ndr->depth--;
1723         ndr->depth--;
1724 }
1725
1726 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1727 {
1728         if (ndr_flags & NDR_SCALARS) {
1729                 NDR_CHECK(ndr_push_align(ndr, 4));
1730                 {
1731                         uint32_t _flags_save_string = ndr->flags;
1732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1733                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1734                         ndr->flags = _flags_save_string;
1735                 }
1736                 {
1737                         uint32_t _flags_save_string = ndr->flags;
1738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1739                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1740                         ndr->flags = _flags_save_string;
1741                 }
1742                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1743         }
1744         if (ndr_flags & NDR_BUFFERS) {
1745                 {
1746                         uint32_t _flags_save_string = ndr->flags;
1747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1748                         if (r->printername) {
1749                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1750                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1751                         }
1752                         ndr->flags = _flags_save_string;
1753                 }
1754                 {
1755                         uint32_t _flags_save_string = ndr->flags;
1756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1757                         if (r->servername) {
1758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1760                         }
1761                         ndr->flags = _flags_save_string;
1762                 }
1763         }
1764         return NDR_ERR_SUCCESS;
1765 }
1766
1767 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1768 {
1769         uint32_t _ptr_printername;
1770         TALLOC_CTX *_mem_save_printername_0;
1771         uint32_t _ptr_servername;
1772         TALLOC_CTX *_mem_save_servername_0;
1773         if (ndr_flags & NDR_SCALARS) {
1774                 NDR_CHECK(ndr_pull_align(ndr, 4));
1775                 {
1776                         uint32_t _flags_save_string = ndr->flags;
1777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1779                         if (_ptr_printername) {
1780                                 NDR_PULL_ALLOC(ndr, r->printername);
1781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1782                         } else {
1783                                 r->printername = NULL;
1784                         }
1785                         ndr->flags = _flags_save_string;
1786                 }
1787                 {
1788                         uint32_t _flags_save_string = ndr->flags;
1789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1791                         if (_ptr_servername) {
1792                                 NDR_PULL_ALLOC(ndr, r->servername);
1793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1794                         } else {
1795                                 r->servername = NULL;
1796                         }
1797                         ndr->flags = _flags_save_string;
1798                 }
1799                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1800         }
1801         if (ndr_flags & NDR_BUFFERS) {
1802                 {
1803                         uint32_t _flags_save_string = ndr->flags;
1804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1805                         if (r->printername) {
1806                                 uint32_t _relative_save_offset;
1807                                 _relative_save_offset = ndr->offset;
1808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1809                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1810                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1813                                 ndr->offset = _relative_save_offset;
1814                         }
1815                         ndr->flags = _flags_save_string;
1816                 }
1817                 {
1818                         uint32_t _flags_save_string = ndr->flags;
1819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1820                         if (r->servername) {
1821                                 uint32_t _relative_save_offset;
1822                                 _relative_save_offset = ndr->offset;
1823                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1824                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1825                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1826                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1827                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1828                                 ndr->offset = _relative_save_offset;
1829                         }
1830                         ndr->flags = _flags_save_string;
1831                 }
1832         }
1833         return NDR_ERR_SUCCESS;
1834 }
1835
1836 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1837 {
1838         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1839         ndr->depth++;
1840         ndr_print_ptr(ndr, "printername", r->printername);
1841         ndr->depth++;
1842         if (r->printername) {
1843                 ndr_print_string(ndr, "printername", r->printername);
1844         }
1845         ndr->depth--;
1846         ndr_print_ptr(ndr, "servername", r->servername);
1847         ndr->depth++;
1848         if (r->servername) {
1849                 ndr_print_string(ndr, "servername", r->servername);
1850         }
1851         ndr->depth--;
1852         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1853         ndr->depth--;
1854 }
1855
1856 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1857 {
1858         if (ndr_flags & NDR_SCALARS) {
1859                 NDR_CHECK(ndr_push_align(ndr, 4));
1860                 {
1861                         uint32_t _flags_save_string = ndr->flags;
1862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1864                         ndr->flags = _flags_save_string;
1865                 }
1866                 {
1867                         uint32_t _flags_save_string = ndr->flags;
1868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1870                         ndr->flags = _flags_save_string;
1871                 }
1872                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1875         }
1876         if (ndr_flags & NDR_BUFFERS) {
1877                 {
1878                         uint32_t _flags_save_string = ndr->flags;
1879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1880                         if (r->printername) {
1881                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1882                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1883                         }
1884                         ndr->flags = _flags_save_string;
1885                 }
1886                 {
1887                         uint32_t _flags_save_string = ndr->flags;
1888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1889                         if (r->portname) {
1890                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1892                         }
1893                         ndr->flags = _flags_save_string;
1894                 }
1895         }
1896         return NDR_ERR_SUCCESS;
1897 }
1898
1899 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1900 {
1901         uint32_t _ptr_printername;
1902         TALLOC_CTX *_mem_save_printername_0;
1903         uint32_t _ptr_portname;
1904         TALLOC_CTX *_mem_save_portname_0;
1905         if (ndr_flags & NDR_SCALARS) {
1906                 NDR_CHECK(ndr_pull_align(ndr, 4));
1907                 {
1908                         uint32_t _flags_save_string = ndr->flags;
1909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1911                         if (_ptr_printername) {
1912                                 NDR_PULL_ALLOC(ndr, r->printername);
1913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1914                         } else {
1915                                 r->printername = NULL;
1916                         }
1917                         ndr->flags = _flags_save_string;
1918                 }
1919                 {
1920                         uint32_t _flags_save_string = ndr->flags;
1921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1923                         if (_ptr_portname) {
1924                                 NDR_PULL_ALLOC(ndr, r->portname);
1925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1926                         } else {
1927                                 r->portname = NULL;
1928                         }
1929                         ndr->flags = _flags_save_string;
1930                 }
1931                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1934         }
1935         if (ndr_flags & NDR_BUFFERS) {
1936                 {
1937                         uint32_t _flags_save_string = ndr->flags;
1938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1939                         if (r->printername) {
1940                                 uint32_t _relative_save_offset;
1941                                 _relative_save_offset = ndr->offset;
1942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1943                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1944                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1947                                 ndr->offset = _relative_save_offset;
1948                         }
1949                         ndr->flags = _flags_save_string;
1950                 }
1951                 {
1952                         uint32_t _flags_save_string = ndr->flags;
1953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1954                         if (r->portname) {
1955                                 uint32_t _relative_save_offset;
1956                                 _relative_save_offset = ndr->offset;
1957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1958                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966         }
1967         return NDR_ERR_SUCCESS;
1968 }
1969
1970 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1971 {
1972         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1973         ndr->depth++;
1974         ndr_print_ptr(ndr, "printername", r->printername);
1975         ndr->depth++;
1976         if (r->printername) {
1977                 ndr_print_string(ndr, "printername", r->printername);
1978         }
1979         ndr->depth--;
1980         ndr_print_ptr(ndr, "portname", r->portname);
1981         ndr->depth++;
1982         if (r->portname) {
1983                 ndr_print_string(ndr, "portname", r->portname);
1984         }
1985         ndr->depth--;
1986         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1987         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1988         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1989         ndr->depth--;
1990 }
1991
1992 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1993 {
1994         if (ndr_flags & NDR_SCALARS) {
1995                 NDR_CHECK(ndr_push_align(ndr, 4));
1996                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1997         }
1998         if (ndr_flags & NDR_BUFFERS) {
1999         }
2000         return NDR_ERR_SUCCESS;
2001 }
2002
2003 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2004 {
2005         if (ndr_flags & NDR_SCALARS) {
2006                 NDR_CHECK(ndr_pull_align(ndr, 4));
2007                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2008         }
2009         if (ndr_flags & NDR_BUFFERS) {
2010         }
2011         return NDR_ERR_SUCCESS;
2012 }
2013
2014 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2015 {
2016         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2017         ndr->depth++;
2018         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2019         ndr->depth--;
2020 }
2021
2022 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2023 {
2024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2025         return NDR_ERR_SUCCESS;
2026 }
2027
2028 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2029 {
2030         uint32_t v;
2031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2032         *r = v;
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2037 {
2038         ndr_print_uint32(ndr, name, r);
2039         ndr->depth++;
2040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2045         ndr->depth--;
2046 }
2047
2048 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2049 {
2050         if (ndr_flags & NDR_SCALARS) {
2051                 NDR_CHECK(ndr_push_align(ndr, 4));
2052                 {
2053                         uint32_t _flags_save_string = ndr->flags;
2054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2055                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2067                         }
2068                         ndr->flags = _flags_save_string;
2069                 }
2070         }
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2075 {
2076         uint32_t _ptr_guid;
2077         TALLOC_CTX *_mem_save_guid_0;
2078         if (ndr_flags & NDR_SCALARS) {
2079                 NDR_CHECK(ndr_pull_align(ndr, 4));
2080                 {
2081                         uint32_t _flags_save_string = ndr->flags;
2082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2084                         if (_ptr_guid) {
2085                                 NDR_PULL_ALLOC(ndr, r->guid);
2086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2087                         } else {
2088                                 r->guid = NULL;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2093         }
2094         if (ndr_flags & NDR_BUFFERS) {
2095                 {
2096                         uint32_t _flags_save_string = ndr->flags;
2097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2098                         if (r->guid) {
2099                                 uint32_t _relative_save_offset;
2100                                 _relative_save_offset = ndr->offset;
2101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2102                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2103                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2106                                 ndr->offset = _relative_save_offset;
2107                         }
2108                         ndr->flags = _flags_save_string;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "guid", r->guid);
2119         ndr->depth++;
2120         if (r->guid) {
2121                 ndr_print_string(ndr, "guid", r->guid);
2122         }
2123         ndr->depth--;
2124         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2125         ndr->depth--;
2126 }
2127
2128 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2129 {
2130         if (ndr_flags & NDR_SCALARS) {
2131                 NDR_CHECK(ndr_push_align(ndr, 4));
2132                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 if (r->devmode) {
2136                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2137                         {
2138                                 struct ndr_push *_ndr_devmode;
2139                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2140                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2141                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2142                         }
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2149 {
2150         uint32_t _ptr_devmode;
2151         TALLOC_CTX *_mem_save_devmode_0;
2152         if (ndr_flags & NDR_SCALARS) {
2153                 NDR_CHECK(ndr_pull_align(ndr, 4));
2154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2155                 if (_ptr_devmode) {
2156                         NDR_PULL_ALLOC(ndr, r->devmode);
2157                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2158                 } else {
2159                         r->devmode = NULL;
2160                 }
2161         }
2162         if (ndr_flags & NDR_BUFFERS) {
2163                 if (r->devmode) {
2164                         uint32_t _relative_save_offset;
2165                         _relative_save_offset = ndr->offset;
2166                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2167                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2168                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2169                         {
2170                                 struct ndr_pull *_ndr_devmode;
2171                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2172                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2173                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2174                         }
2175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2176                         ndr->offset = _relative_save_offset;
2177                 }
2178         }
2179         return NDR_ERR_SUCCESS;
2180 }
2181
2182 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2183 {
2184         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2185         ndr->depth++;
2186         ndr_print_ptr(ndr, "devmode", r->devmode);
2187         ndr->depth++;
2188         if (r->devmode) {
2189                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2190         }
2191         ndr->depth--;
2192         ndr->depth--;
2193 }
2194
2195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2196 {
2197         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2198         if (ndr_flags & NDR_SCALARS) {
2199                 int level = ndr_push_get_switch_value(ndr, r);
2200                 switch (level) {
2201                         case 0: {
2202                                 NDR_CHECK(ndr_push_align(ndr, 4));
2203                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2204                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2205                         break; }
2206
2207                         case 1: {
2208                                 NDR_CHECK(ndr_push_align(ndr, 4));
2209                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2210                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2211                         break; }
2212
2213                         case 2: {
2214                                 NDR_CHECK(ndr_push_align(ndr, 4));
2215                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2216                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2217                         break; }
2218
2219                         case 3: {
2220                                 NDR_CHECK(ndr_push_align(ndr, 4));
2221                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2222                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2223                         break; }
2224
2225                         case 4: {
2226                                 NDR_CHECK(ndr_push_align(ndr, 4));
2227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2228                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2229                         break; }
2230
2231                         case 5: {
2232                                 NDR_CHECK(ndr_push_align(ndr, 4));
2233                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2234                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2235                         break; }
2236
2237                         case 6: {
2238                                 NDR_CHECK(ndr_push_align(ndr, 4));
2239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2240                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2241                         break; }
2242
2243                         case 7: {
2244                                 NDR_CHECK(ndr_push_align(ndr, 4));
2245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2246                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2247                         break; }
2248
2249                         case 8: {
2250                                 NDR_CHECK(ndr_push_align(ndr, 4));
2251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2252                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2253                         break; }
2254
2255                         case 9: {
2256                                 NDR_CHECK(ndr_push_align(ndr, 4));
2257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2258                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2259                         break; }
2260
2261                         default: {
2262                         break; }
2263
2264                 }
2265         }
2266         if (ndr_flags & NDR_BUFFERS) {
2267                 int level = ndr_push_get_switch_value(ndr, r);
2268                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2269                 switch (level) {
2270                         case 0:
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2272                         break;
2273
2274                         case 1:
2275                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2276                         break;
2277
2278                         case 2:
2279                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2280                         break;
2281
2282                         case 3:
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2284                         break;
2285
2286                         case 4:
2287                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2288                         break;
2289
2290                         case 5:
2291                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2292                         break;
2293
2294                         case 6:
2295                         break;
2296
2297                         case 7:
2298                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2299                         break;
2300
2301                         case 8:
2302                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2303                         break;
2304
2305                         case 9:
2306                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2307                         break;
2308
2309                         default:
2310                         break;
2311
2312                 }
2313         }
2314         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2315         return NDR_ERR_SUCCESS;
2316 }
2317
2318 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2319 {
2320         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2321         int level;
2322         level = ndr_pull_get_switch_value(ndr, r);
2323         if (ndr_flags & NDR_SCALARS) {
2324                 switch (level) {
2325                         case 0: {
2326                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2327                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2328                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2329                         break; }
2330
2331                         case 1: {
2332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2334                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2335                         break; }
2336
2337                         case 2: {
2338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2340                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2341                         break; }
2342
2343                         case 3: {
2344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2346                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2347                         break; }
2348
2349                         case 4: {
2350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2352                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2353                         break; }
2354
2355                         case 5: {
2356                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2357                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2358                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2359                         break; }
2360
2361                         case 6: {
2362                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2363                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2365                         break; }
2366
2367                         case 7: {
2368                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2369                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2370                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2371                         break; }
2372
2373                         case 8: {
2374                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2375                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2376                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2377                         break; }
2378
2379                         case 9: {
2380                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2381                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2382                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2383                         break; }
2384
2385                         default: {
2386                         break; }
2387
2388                 }
2389         }
2390         if (ndr_flags & NDR_BUFFERS) {
2391                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2392                 switch (level) {
2393                         case 0:
2394                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2395                         break;
2396
2397                         case 1:
2398                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2399                         break;
2400
2401                         case 2:
2402                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2403                         break;
2404
2405                         case 3:
2406                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2407                         break;
2408
2409                         case 4:
2410                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2411                         break;
2412
2413                         case 5:
2414                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2415                         break;
2416
2417                         case 6:
2418                         break;
2419
2420                         case 7:
2421                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2422                         break;
2423
2424                         case 8:
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2426                         break;
2427
2428                         case 9:
2429                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2430                         break;
2431
2432                         default:
2433                         break;
2434
2435                 }
2436         }
2437         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2438         return NDR_ERR_SUCCESS;
2439 }
2440
2441 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2442 {
2443         int level;
2444         level = ndr_print_get_switch_value(ndr, r);
2445         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2446         switch (level) {
2447                 case 0:
2448                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2449                 break;
2450
2451                 case 1:
2452                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2453                 break;
2454
2455                 case 2:
2456                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2457                 break;
2458
2459                 case 3:
2460                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2461                 break;
2462
2463                 case 4:
2464                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2465                 break;
2466
2467                 case 5:
2468                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2469                 break;
2470
2471                 case 6:
2472                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2473                 break;
2474
2475                 case 7:
2476                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2477                 break;
2478
2479                 case 8:
2480                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2481                 break;
2482
2483                 case 9:
2484                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2485                 break;
2486
2487                 default:
2488                 break;
2489
2490         }
2491 }
2492
2493 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2494 {
2495         if (ndr_flags & NDR_SCALARS) {
2496                 NDR_CHECK(ndr_push_align(ndr, 4));
2497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501                 if (r->devmode) {
2502                         {
2503                                 struct ndr_push *_ndr_devmode;
2504                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2505                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2506                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2507                         }
2508                 }
2509         }
2510         return NDR_ERR_SUCCESS;
2511 }
2512
2513 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2514 {
2515         uint32_t _ptr_devmode;
2516         TALLOC_CTX *_mem_save_devmode_0;
2517         if (ndr_flags & NDR_SCALARS) {
2518                 NDR_CHECK(ndr_pull_align(ndr, 4));
2519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2521                 if (_ptr_devmode) {
2522                         NDR_PULL_ALLOC(ndr, r->devmode);
2523                 } else {
2524                         r->devmode = NULL;
2525                 }
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528                 if (r->devmode) {
2529                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2530                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2531                         {
2532                                 struct ndr_pull *_ndr_devmode;
2533                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2534                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2535                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2536                         }
2537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2538                 }
2539         }
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2544 {
2545         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2546         ndr->depth++;
2547         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);
2548         ndr_print_ptr(ndr, "devmode", r->devmode);
2549         ndr->depth++;
2550         if (r->devmode) {
2551                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2552         }
2553         ndr->depth--;
2554         ndr->depth--;
2555 }
2556
2557 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2558 {
2559         if (ndr_flags & NDR_SCALARS) {
2560                 NDR_CHECK(ndr_push_align(ndr, 4));
2561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2562                 {
2563                         uint32_t _flags_save_string = ndr->flags;
2564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2566                         ndr->flags = _flags_save_string;
2567                 }
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2572                         ndr->flags = _flags_save_string;
2573                 }
2574                 {
2575                         uint32_t _flags_save_string = ndr->flags;
2576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2578                         ndr->flags = _flags_save_string;
2579                 }
2580                 {
2581                         uint32_t _flags_save_string = ndr->flags;
2582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2584                         ndr->flags = _flags_save_string;
2585                 }
2586                 {
2587                         uint32_t _flags_save_string = ndr->flags;
2588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2590                         ndr->flags = _flags_save_string;
2591                 }
2592                 {
2593                         uint32_t _flags_save_string = ndr->flags;
2594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2596                         ndr->flags = _flags_save_string;
2597                 }
2598                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2603                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2604         }
2605         if (ndr_flags & NDR_BUFFERS) {
2606                 {
2607                         uint32_t _flags_save_string = ndr->flags;
2608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2609                         if (r->printer_name) {
2610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615                 {
2616                         uint32_t _flags_save_string = ndr->flags;
2617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2618                         if (r->server_name) {
2619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2621                         }
2622                         ndr->flags = _flags_save_string;
2623                 }
2624                 {
2625                         uint32_t _flags_save_string = ndr->flags;
2626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2627                         if (r->user_name) {
2628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2630                         }
2631                         ndr->flags = _flags_save_string;
2632                 }
2633                 {
2634                         uint32_t _flags_save_string = ndr->flags;
2635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2636                         if (r->document_name) {
2637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2639                         }
2640                         ndr->flags = _flags_save_string;
2641                 }
2642                 {
2643                         uint32_t _flags_save_string = ndr->flags;
2644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2645                         if (r->data_type) {
2646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2648                         }
2649                         ndr->flags = _flags_save_string;
2650                 }
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->text_status) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660         }
2661         return NDR_ERR_SUCCESS;
2662 }
2663
2664 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2665 {
2666         uint32_t _ptr_printer_name;
2667         TALLOC_CTX *_mem_save_printer_name_0;
2668         uint32_t _ptr_server_name;
2669         TALLOC_CTX *_mem_save_server_name_0;
2670         uint32_t _ptr_user_name;
2671         TALLOC_CTX *_mem_save_user_name_0;
2672         uint32_t _ptr_document_name;
2673         TALLOC_CTX *_mem_save_document_name_0;
2674         uint32_t _ptr_data_type;
2675         TALLOC_CTX *_mem_save_data_type_0;
2676         uint32_t _ptr_text_status;
2677         TALLOC_CTX *_mem_save_text_status_0;
2678         if (ndr_flags & NDR_SCALARS) {
2679                 NDR_CHECK(ndr_pull_align(ndr, 4));
2680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2685                         if (_ptr_printer_name) {
2686                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2688                         } else {
2689                                 r->printer_name = NULL;
2690                         }
2691                         ndr->flags = _flags_save_string;
2692                 }
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2697                         if (_ptr_server_name) {
2698                                 NDR_PULL_ALLOC(ndr, r->server_name);
2699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2700                         } else {
2701                                 r->server_name = NULL;
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705                 {
2706                         uint32_t _flags_save_string = ndr->flags;
2707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2708                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2709                         if (_ptr_user_name) {
2710                                 NDR_PULL_ALLOC(ndr, r->user_name);
2711                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2712                         } else {
2713                                 r->user_name = NULL;
2714                         }
2715                         ndr->flags = _flags_save_string;
2716                 }
2717                 {
2718                         uint32_t _flags_save_string = ndr->flags;
2719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2721                         if (_ptr_document_name) {
2722                                 NDR_PULL_ALLOC(ndr, r->document_name);
2723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2724                         } else {
2725                                 r->document_name = NULL;
2726                         }
2727                         ndr->flags = _flags_save_string;
2728                 }
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2733                         if (_ptr_data_type) {
2734                                 NDR_PULL_ALLOC(ndr, r->data_type);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2736                         } else {
2737                                 r->data_type = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2745                         if (_ptr_text_status) {
2746                                 NDR_PULL_ALLOC(ndr, r->text_status);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2748                         } else {
2749                                 r->text_status = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2758                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2759         }
2760         if (ndr_flags & NDR_BUFFERS) {
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         if (r->printer_name) {
2765                                 uint32_t _relative_save_offset;
2766                                 _relative_save_offset = ndr->offset;
2767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2768                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2769                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2772                                 ndr->offset = _relative_save_offset;
2773                         }
2774                         ndr->flags = _flags_save_string;
2775                 }
2776                 {
2777                         uint32_t _flags_save_string = ndr->flags;
2778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2779                         if (r->server_name) {
2780                                 uint32_t _relative_save_offset;
2781                                 _relative_save_offset = ndr->offset;
2782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2783                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2787                                 ndr->offset = _relative_save_offset;
2788                         }
2789                         ndr->flags = _flags_save_string;
2790                 }
2791                 {
2792                         uint32_t _flags_save_string = ndr->flags;
2793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2794                         if (r->user_name) {
2795                                 uint32_t _relative_save_offset;
2796                                 _relative_save_offset = ndr->offset;
2797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2798                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2799                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2802                                 ndr->offset = _relative_save_offset;
2803                         }
2804                         ndr->flags = _flags_save_string;
2805                 }
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->document_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2813                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_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->data_type) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2828                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_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->text_status) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2843                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851         }
2852         return NDR_ERR_SUCCESS;
2853 }
2854
2855 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2856 {
2857         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2858         ndr->depth++;
2859         ndr_print_uint32(ndr, "job_id", r->job_id);
2860         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2861         ndr->depth++;
2862         if (r->printer_name) {
2863                 ndr_print_string(ndr, "printer_name", r->printer_name);
2864         }
2865         ndr->depth--;
2866         ndr_print_ptr(ndr, "server_name", r->server_name);
2867         ndr->depth++;
2868         if (r->server_name) {
2869                 ndr_print_string(ndr, "server_name", r->server_name);
2870         }
2871         ndr->depth--;
2872         ndr_print_ptr(ndr, "user_name", r->user_name);
2873         ndr->depth++;
2874         if (r->user_name) {
2875                 ndr_print_string(ndr, "user_name", r->user_name);
2876         }
2877         ndr->depth--;
2878         ndr_print_ptr(ndr, "document_name", r->document_name);
2879         ndr->depth++;
2880         if (r->document_name) {
2881                 ndr_print_string(ndr, "document_name", r->document_name);
2882         }
2883         ndr->depth--;
2884         ndr_print_ptr(ndr, "data_type", r->data_type);
2885         ndr->depth++;
2886         if (r->data_type) {
2887                 ndr_print_string(ndr, "data_type", r->data_type);
2888         }
2889         ndr->depth--;
2890         ndr_print_ptr(ndr, "text_status", r->text_status);
2891         ndr->depth++;
2892         if (r->text_status) {
2893                 ndr_print_string(ndr, "text_status", r->text_status);
2894         }
2895         ndr->depth--;
2896         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2897         ndr_print_uint32(ndr, "priority", r->priority);
2898         ndr_print_uint32(ndr, "position", r->position);
2899         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2900         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2901         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2902         ndr->depth--;
2903 }
2904
2905 static enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2906 {
2907         if (ndr_flags & NDR_SCALARS) {
2908                 NDR_CHECK(ndr_push_align(ndr, 4));
2909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2910                 {
2911                         uint32_t _flags_save_string = ndr->flags;
2912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2913                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2914                         ndr->flags = _flags_save_string;
2915                 }
2916                 {
2917                         uint32_t _flags_save_string = ndr->flags;
2918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2919                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2920                         ndr->flags = _flags_save_string;
2921                 }
2922                 {
2923                         uint32_t _flags_save_string = ndr->flags;
2924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2925                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2926                         ndr->flags = _flags_save_string;
2927                 }
2928                 {
2929                         uint32_t _flags_save_string = ndr->flags;
2930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2931                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2932                         ndr->flags = _flags_save_string;
2933                 }
2934                 {
2935                         uint32_t _flags_save_string = ndr->flags;
2936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2937                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2938                         ndr->flags = _flags_save_string;
2939                 }
2940                 {
2941                         uint32_t _flags_save_string = ndr->flags;
2942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2944                         ndr->flags = _flags_save_string;
2945                 }
2946                 {
2947                         uint32_t _flags_save_string = ndr->flags;
2948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2949                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
2950                         ndr->flags = _flags_save_string;
2951                 }
2952                 {
2953                         uint32_t _flags_save_string = ndr->flags;
2954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2955                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
2956                         ndr->flags = _flags_save_string;
2957                 }
2958                 {
2959                         uint32_t _flags_save_string = ndr->flags;
2960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2961                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
2962                         ndr->flags = _flags_save_string;
2963                 }
2964                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2965                 {
2966                         uint32_t _flags_save_string = ndr->flags;
2967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2968                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2969                         ndr->flags = _flags_save_string;
2970                 }
2971                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2972                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
2976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
2977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2979                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2982         }
2983         if (ndr_flags & NDR_BUFFERS) {
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         if (r->printer_name) {
2988                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2989                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2990                         }
2991                         ndr->flags = _flags_save_string;
2992                 }
2993                 {
2994                         uint32_t _flags_save_string = ndr->flags;
2995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2996                         if (r->server_name) {
2997                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2999                         }
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                         if (r->user_name) {
3006                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3007                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3008                         }
3009                         ndr->flags = _flags_save_string;
3010                 }
3011                 {
3012                         uint32_t _flags_save_string = ndr->flags;
3013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3014                         if (r->document_name) {
3015                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3017                         }
3018                         ndr->flags = _flags_save_string;
3019                 }
3020                 {
3021                         uint32_t _flags_save_string = ndr->flags;
3022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3023                         if (r->notify_name) {
3024                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3025                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3026                         }
3027                         ndr->flags = _flags_save_string;
3028                 }
3029                 {
3030                         uint32_t _flags_save_string = ndr->flags;
3031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3032                         if (r->data_type) {
3033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3035                         }
3036                         ndr->flags = _flags_save_string;
3037                 }
3038                 {
3039                         uint32_t _flags_save_string = ndr->flags;
3040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3041                         if (r->print_processor) {
3042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3044                         }
3045                         ndr->flags = _flags_save_string;
3046                 }
3047                 {
3048                         uint32_t _flags_save_string = ndr->flags;
3049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3050                         if (r->parameters) {
3051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3053                         }
3054                         ndr->flags = _flags_save_string;
3055                 }
3056                 {
3057                         uint32_t _flags_save_string = ndr->flags;
3058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3059                         if (r->driver_name) {
3060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3062                         }
3063                         ndr->flags = _flags_save_string;
3064                 }
3065                 if (r->devmode) {
3066                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3067                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3068                 }
3069                 {
3070                         uint32_t _flags_save_string = ndr->flags;
3071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3072                         if (r->text_status) {
3073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3075                         }
3076                         ndr->flags = _flags_save_string;
3077                 }
3078                 if (r->secdesc) {
3079                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3080                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3081                 }
3082         }
3083         return NDR_ERR_SUCCESS;
3084 }
3085
3086 static enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3087 {
3088         uint32_t _ptr_printer_name;
3089         TALLOC_CTX *_mem_save_printer_name_0;
3090         uint32_t _ptr_server_name;
3091         TALLOC_CTX *_mem_save_server_name_0;
3092         uint32_t _ptr_user_name;
3093         TALLOC_CTX *_mem_save_user_name_0;
3094         uint32_t _ptr_document_name;
3095         TALLOC_CTX *_mem_save_document_name_0;
3096         uint32_t _ptr_notify_name;
3097         TALLOC_CTX *_mem_save_notify_name_0;
3098         uint32_t _ptr_data_type;
3099         TALLOC_CTX *_mem_save_data_type_0;
3100         uint32_t _ptr_print_processor;
3101         TALLOC_CTX *_mem_save_print_processor_0;
3102         uint32_t _ptr_parameters;
3103         TALLOC_CTX *_mem_save_parameters_0;
3104         uint32_t _ptr_driver_name;
3105         TALLOC_CTX *_mem_save_driver_name_0;
3106         uint32_t _ptr_devmode;
3107         TALLOC_CTX *_mem_save_devmode_0;
3108         uint32_t _ptr_text_status;
3109         TALLOC_CTX *_mem_save_text_status_0;
3110         uint32_t _ptr_secdesc;
3111         TALLOC_CTX *_mem_save_secdesc_0;
3112         if (ndr_flags & NDR_SCALARS) {
3113                 NDR_CHECK(ndr_pull_align(ndr, 4));
3114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3115                 {
3116                         uint32_t _flags_save_string = ndr->flags;
3117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3119                         if (_ptr_printer_name) {
3120                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3122                         } else {
3123                                 r->printer_name = NULL;
3124                         }
3125                         ndr->flags = _flags_save_string;
3126                 }
3127                 {
3128                         uint32_t _flags_save_string = ndr->flags;
3129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3131                         if (_ptr_server_name) {
3132                                 NDR_PULL_ALLOC(ndr, r->server_name);
3133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3134                         } else {
3135                                 r->server_name = NULL;
3136                         }
3137                         ndr->flags = _flags_save_string;
3138                 }
3139                 {
3140                         uint32_t _flags_save_string = ndr->flags;
3141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3143                         if (_ptr_user_name) {
3144                                 NDR_PULL_ALLOC(ndr, r->user_name);
3145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3146                         } else {
3147                                 r->user_name = NULL;
3148                         }
3149                         ndr->flags = _flags_save_string;
3150                 }
3151                 {
3152                         uint32_t _flags_save_string = ndr->flags;
3153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3155                         if (_ptr_document_name) {
3156                                 NDR_PULL_ALLOC(ndr, r->document_name);
3157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3158                         } else {
3159                                 r->document_name = NULL;
3160                         }
3161                         ndr->flags = _flags_save_string;
3162                 }
3163                 {
3164                         uint32_t _flags_save_string = ndr->flags;
3165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3167                         if (_ptr_notify_name) {
3168                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3170                         } else {
3171                                 r->notify_name = NULL;
3172                         }
3173                         ndr->flags = _flags_save_string;
3174                 }
3175                 {
3176                         uint32_t _flags_save_string = ndr->flags;
3177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3179                         if (_ptr_data_type) {
3180                                 NDR_PULL_ALLOC(ndr, r->data_type);
3181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3182                         } else {
3183                                 r->data_type = NULL;
3184                         }
3185                         ndr->flags = _flags_save_string;
3186                 }
3187                 {
3188                         uint32_t _flags_save_string = ndr->flags;
3189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3191                         if (_ptr_print_processor) {
3192                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3194                         } else {
3195                                 r->print_processor = NULL;
3196                         }
3197                         ndr->flags = _flags_save_string;
3198                 }
3199                 {
3200                         uint32_t _flags_save_string = ndr->flags;
3201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3202                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3203                         if (_ptr_parameters) {
3204                                 NDR_PULL_ALLOC(ndr, r->parameters);
3205                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3206                         } else {
3207                                 r->parameters = NULL;
3208                         }
3209                         ndr->flags = _flags_save_string;
3210                 }
3211                 {
3212                         uint32_t _flags_save_string = ndr->flags;
3213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3215                         if (_ptr_driver_name) {
3216                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3218                         } else {
3219                                 r->driver_name = NULL;
3220                         }
3221                         ndr->flags = _flags_save_string;
3222                 }
3223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3224                 if (_ptr_devmode) {
3225                         NDR_PULL_ALLOC(ndr, r->devmode);
3226                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3227                 } else {
3228                         r->devmode = NULL;
3229                 }
3230                 {
3231                         uint32_t _flags_save_string = ndr->flags;
3232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3233                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3234                         if (_ptr_text_status) {
3235                                 NDR_PULL_ALLOC(ndr, r->text_status);
3236                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3237                         } else {
3238                                 r->text_status = NULL;
3239                         }
3240                         ndr->flags = _flags_save_string;
3241                 }
3242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3243                 if (_ptr_secdesc) {
3244                         NDR_PULL_ALLOC(ndr, r->secdesc);
3245                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3246                 } else {
3247                         r->secdesc = NULL;
3248                 }
3249                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3256                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3259         }
3260         if (ndr_flags & NDR_BUFFERS) {
3261                 {
3262                         uint32_t _flags_save_string = ndr->flags;
3263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3264                         if (r->printer_name) {
3265                                 uint32_t _relative_save_offset;
3266                                 _relative_save_offset = ndr->offset;
3267                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3268                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3269                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3270                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3271                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3272                                 ndr->offset = _relative_save_offset;
3273                         }
3274                         ndr->flags = _flags_save_string;
3275                 }
3276                 {
3277                         uint32_t _flags_save_string = ndr->flags;
3278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3279                         if (r->server_name) {
3280                                 uint32_t _relative_save_offset;
3281                                 _relative_save_offset = ndr->offset;
3282                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3283                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3284                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3285                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3286                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3287                                 ndr->offset = _relative_save_offset;
3288                         }
3289                         ndr->flags = _flags_save_string;
3290                 }
3291                 {
3292                         uint32_t _flags_save_string = ndr->flags;
3293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3294                         if (r->user_name) {
3295                                 uint32_t _relative_save_offset;
3296                                 _relative_save_offset = ndr->offset;
3297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3298                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3299                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3302                                 ndr->offset = _relative_save_offset;
3303                         }
3304                         ndr->flags = _flags_save_string;
3305                 }
3306                 {
3307                         uint32_t _flags_save_string = ndr->flags;
3308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3309                         if (r->document_name) {
3310                                 uint32_t _relative_save_offset;
3311                                 _relative_save_offset = ndr->offset;
3312                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3313                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3314                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3315                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3316                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3317                                 ndr->offset = _relative_save_offset;
3318                         }
3319                         ndr->flags = _flags_save_string;
3320                 }
3321                 {
3322                         uint32_t _flags_save_string = ndr->flags;
3323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3324                         if (r->notify_name) {
3325                                 uint32_t _relative_save_offset;
3326                                 _relative_save_offset = ndr->offset;
3327                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3328                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3329                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3330                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3331                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3332                                 ndr->offset = _relative_save_offset;
3333                         }
3334                         ndr->flags = _flags_save_string;
3335                 }
3336                 {
3337                         uint32_t _flags_save_string = ndr->flags;
3338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3339                         if (r->data_type) {
3340                                 uint32_t _relative_save_offset;
3341                                 _relative_save_offset = ndr->offset;
3342                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3343                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3345                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3346                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3347                                 ndr->offset = _relative_save_offset;
3348                         }
3349                         ndr->flags = _flags_save_string;
3350                 }
3351                 {
3352                         uint32_t _flags_save_string = ndr->flags;
3353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3354                         if (r->print_processor) {
3355                                 uint32_t _relative_save_offset;
3356                                 _relative_save_offset = ndr->offset;
3357                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3358                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3359                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3360                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3361                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3362                                 ndr->offset = _relative_save_offset;
3363                         }
3364                         ndr->flags = _flags_save_string;
3365                 }
3366                 {
3367                         uint32_t _flags_save_string = ndr->flags;
3368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3369                         if (r->parameters) {
3370                                 uint32_t _relative_save_offset;
3371                                 _relative_save_offset = ndr->offset;
3372                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3373                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3374                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3375                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3376                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3377                                 ndr->offset = _relative_save_offset;
3378                         }
3379                         ndr->flags = _flags_save_string;
3380                 }
3381                 {
3382                         uint32_t _flags_save_string = ndr->flags;
3383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3384                         if (r->driver_name) {
3385                                 uint32_t _relative_save_offset;
3386                                 _relative_save_offset = ndr->offset;
3387                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3388                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3389                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3390                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3391                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3392                                 ndr->offset = _relative_save_offset;
3393                         }
3394                         ndr->flags = _flags_save_string;
3395                 }
3396                 if (r->devmode) {
3397                         uint32_t _relative_save_offset;
3398                         _relative_save_offset = ndr->offset;
3399                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3400                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3401                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3402                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3404                         ndr->offset = _relative_save_offset;
3405                 }
3406                 {
3407                         uint32_t _flags_save_string = ndr->flags;
3408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3409                         if (r->text_status) {
3410                                 uint32_t _relative_save_offset;
3411                                 _relative_save_offset = ndr->offset;
3412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3413                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3414                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3417                                 ndr->offset = _relative_save_offset;
3418                         }
3419                         ndr->flags = _flags_save_string;
3420                 }
3421                 if (r->secdesc) {
3422                         uint32_t _relative_save_offset;
3423                         _relative_save_offset = ndr->offset;
3424                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3425                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3426                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3427                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3429                         ndr->offset = _relative_save_offset;
3430                 }
3431         }
3432         return NDR_ERR_SUCCESS;
3433 }
3434
3435 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3436 {
3437         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3438         ndr->depth++;
3439         ndr_print_uint32(ndr, "job_id", r->job_id);
3440         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3441         ndr->depth++;
3442         if (r->printer_name) {
3443                 ndr_print_string(ndr, "printer_name", r->printer_name);
3444         }
3445         ndr->depth--;
3446         ndr_print_ptr(ndr, "server_name", r->server_name);
3447         ndr->depth++;
3448         if (r->server_name) {
3449                 ndr_print_string(ndr, "server_name", r->server_name);
3450         }
3451         ndr->depth--;
3452         ndr_print_ptr(ndr, "user_name", r->user_name);
3453         ndr->depth++;
3454         if (r->user_name) {
3455                 ndr_print_string(ndr, "user_name", r->user_name);
3456         }
3457         ndr->depth--;
3458         ndr_print_ptr(ndr, "document_name", r->document_name);
3459         ndr->depth++;
3460         if (r->document_name) {
3461                 ndr_print_string(ndr, "document_name", r->document_name);
3462         }
3463         ndr->depth--;
3464         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3465         ndr->depth++;
3466         if (r->notify_name) {
3467                 ndr_print_string(ndr, "notify_name", r->notify_name);
3468         }
3469         ndr->depth--;
3470         ndr_print_ptr(ndr, "data_type", r->data_type);
3471         ndr->depth++;
3472         if (r->data_type) {
3473                 ndr_print_string(ndr, "data_type", r->data_type);
3474         }
3475         ndr->depth--;
3476         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3477         ndr->depth++;
3478         if (r->print_processor) {
3479                 ndr_print_string(ndr, "print_processor", r->print_processor);
3480         }
3481         ndr->depth--;
3482         ndr_print_ptr(ndr, "parameters", r->parameters);
3483         ndr->depth++;
3484         if (r->parameters) {
3485                 ndr_print_string(ndr, "parameters", r->parameters);
3486         }
3487         ndr->depth--;
3488         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3489         ndr->depth++;
3490         if (r->driver_name) {
3491                 ndr_print_string(ndr, "driver_name", r->driver_name);
3492         }
3493         ndr->depth--;
3494         ndr_print_ptr(ndr, "devmode", r->devmode);
3495         ndr->depth++;
3496         if (r->devmode) {
3497                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3498         }
3499         ndr->depth--;
3500         ndr_print_ptr(ndr, "text_status", r->text_status);
3501         ndr->depth++;
3502         if (r->text_status) {
3503                 ndr_print_string(ndr, "text_status", r->text_status);
3504         }
3505         ndr->depth--;
3506         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3507         ndr->depth++;
3508         if (r->secdesc) {
3509                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3510         }
3511         ndr->depth--;
3512         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3513         ndr_print_uint32(ndr, "priority", r->priority);
3514         ndr_print_uint32(ndr, "position", r->position);
3515         ndr_print_uint32(ndr, "start_time", r->start_time);
3516         ndr_print_uint32(ndr, "until_time", r->until_time);
3517         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3518         ndr_print_uint32(ndr, "size", r->size);
3519         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3520         ndr_print_uint32(ndr, "time", r->time);
3521         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3522         ndr->depth--;
3523 }
3524
3525 static enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3526 {
3527         if (ndr_flags & NDR_SCALARS) {
3528                 NDR_CHECK(ndr_push_align(ndr, 4));
3529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3532         }
3533         if (ndr_flags & NDR_BUFFERS) {
3534         }
3535         return NDR_ERR_SUCCESS;
3536 }
3537
3538 static enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3539 {
3540         if (ndr_flags & NDR_SCALARS) {
3541                 NDR_CHECK(ndr_pull_align(ndr, 4));
3542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3545         }
3546         if (ndr_flags & NDR_BUFFERS) {
3547         }
3548         return NDR_ERR_SUCCESS;
3549 }
3550
3551 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3552 {
3553         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3554         ndr->depth++;
3555         ndr_print_uint32(ndr, "job_id", r->job_id);
3556         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3557         ndr_print_uint32(ndr, "reserved", r->reserved);
3558         ndr->depth--;
3559 }
3560
3561 static enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3562 {
3563         if (ndr_flags & NDR_SCALARS) {
3564                 NDR_CHECK(ndr_push_align(ndr, 4));
3565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3566                 {
3567                         uint32_t _flags_save_string = ndr->flags;
3568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3570                         ndr->flags = _flags_save_string;
3571                 }
3572                 {
3573                         uint32_t _flags_save_string = ndr->flags;
3574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3576                         ndr->flags = _flags_save_string;
3577                 }
3578                 {
3579                         uint32_t _flags_save_string = ndr->flags;
3580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3582                         ndr->flags = _flags_save_string;
3583                 }
3584                 {
3585                         uint32_t _flags_save_string = ndr->flags;
3586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3588                         ndr->flags = _flags_save_string;
3589                 }
3590                 {
3591                         uint32_t _flags_save_string = ndr->flags;
3592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3594                         ndr->flags = _flags_save_string;
3595                 }
3596                 {
3597                         uint32_t _flags_save_string = ndr->flags;
3598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3600                         ndr->flags = _flags_save_string;
3601                 }
3602                 {
3603                         uint32_t _flags_save_string = ndr->flags;
3604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3606                         ndr->flags = _flags_save_string;
3607                 }
3608                 {
3609                         uint32_t _flags_save_string = ndr->flags;
3610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3611                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3612                         ndr->flags = _flags_save_string;
3613                 }
3614                 {
3615                         uint32_t _flags_save_string = ndr->flags;
3616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3618                         ndr->flags = _flags_save_string;
3619                 }
3620                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3621                 {
3622                         uint32_t _flags_save_string = ndr->flags;
3623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3625                         ndr->flags = _flags_save_string;
3626                 }
3627                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3628                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3635                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3639         }
3640         if (ndr_flags & NDR_BUFFERS) {
3641                 {
3642                         uint32_t _flags_save_string = ndr->flags;
3643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3644                         if (r->printer_name) {
3645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3647                         }
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                         if (r->server_name) {
3654                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3656                         }
3657                         ndr->flags = _flags_save_string;
3658                 }
3659                 {
3660                         uint32_t _flags_save_string = ndr->flags;
3661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3662                         if (r->user_name) {
3663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3665                         }
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                         if (r->document_name) {
3672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3674                         }
3675                         ndr->flags = _flags_save_string;
3676                 }
3677                 {
3678                         uint32_t _flags_save_string = ndr->flags;
3679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3680                         if (r->notify_name) {
3681                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3682                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3683                         }
3684                         ndr->flags = _flags_save_string;
3685                 }
3686                 {
3687                         uint32_t _flags_save_string = ndr->flags;
3688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3689                         if (r->data_type) {
3690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3692                         }
3693                         ndr->flags = _flags_save_string;
3694                 }
3695                 {
3696                         uint32_t _flags_save_string = ndr->flags;
3697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3698                         if (r->print_processor) {
3699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3701                         }
3702                         ndr->flags = _flags_save_string;
3703                 }
3704                 {
3705                         uint32_t _flags_save_string = ndr->flags;
3706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3707                         if (r->parameters) {
3708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3710                         }
3711                         ndr->flags = _flags_save_string;
3712                 }
3713                 {
3714                         uint32_t _flags_save_string = ndr->flags;
3715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3716                         if (r->driver_name) {
3717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3719                         }
3720                         ndr->flags = _flags_save_string;
3721                 }
3722                 if (r->devmode) {
3723                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3724                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3725                 }
3726                 {
3727                         uint32_t _flags_save_string = ndr->flags;
3728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3729                         if (r->text_status) {
3730                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3731                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3732                         }
3733                         ndr->flags = _flags_save_string;
3734                 }
3735                 if (r->secdesc) {
3736                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3737                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3738                 }
3739         }
3740         return NDR_ERR_SUCCESS;
3741 }
3742
3743 static enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3744 {
3745         uint32_t _ptr_printer_name;
3746         TALLOC_CTX *_mem_save_printer_name_0;
3747         uint32_t _ptr_server_name;
3748         TALLOC_CTX *_mem_save_server_name_0;
3749         uint32_t _ptr_user_name;
3750         TALLOC_CTX *_mem_save_user_name_0;
3751         uint32_t _ptr_document_name;
3752         TALLOC_CTX *_mem_save_document_name_0;
3753         uint32_t _ptr_notify_name;
3754         TALLOC_CTX *_mem_save_notify_name_0;
3755         uint32_t _ptr_data_type;
3756         TALLOC_CTX *_mem_save_data_type_0;
3757         uint32_t _ptr_print_processor;
3758         TALLOC_CTX *_mem_save_print_processor_0;
3759         uint32_t _ptr_parameters;
3760         TALLOC_CTX *_mem_save_parameters_0;
3761         uint32_t _ptr_driver_name;
3762         TALLOC_CTX *_mem_save_driver_name_0;
3763         uint32_t _ptr_devmode;
3764         TALLOC_CTX *_mem_save_devmode_0;
3765         uint32_t _ptr_text_status;
3766         TALLOC_CTX *_mem_save_text_status_0;
3767         uint32_t _ptr_secdesc;
3768         TALLOC_CTX *_mem_save_secdesc_0;
3769         if (ndr_flags & NDR_SCALARS) {
3770                 NDR_CHECK(ndr_pull_align(ndr, 4));
3771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3772                 {
3773                         uint32_t _flags_save_string = ndr->flags;
3774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3776                         if (_ptr_printer_name) {
3777                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3779                         } else {
3780                                 r->printer_name = NULL;
3781                         }
3782                         ndr->flags = _flags_save_string;
3783                 }
3784                 {
3785                         uint32_t _flags_save_string = ndr->flags;
3786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3788                         if (_ptr_server_name) {
3789                                 NDR_PULL_ALLOC(ndr, r->server_name);
3790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3791                         } else {
3792                                 r->server_name = NULL;
3793                         }
3794                         ndr->flags = _flags_save_string;
3795                 }
3796                 {
3797                         uint32_t _flags_save_string = ndr->flags;
3798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3800                         if (_ptr_user_name) {
3801                                 NDR_PULL_ALLOC(ndr, r->user_name);
3802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3803                         } else {
3804                                 r->user_name = NULL;
3805                         }
3806                         ndr->flags = _flags_save_string;
3807                 }
3808                 {
3809                         uint32_t _flags_save_string = ndr->flags;
3810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3812                         if (_ptr_document_name) {
3813                                 NDR_PULL_ALLOC(ndr, r->document_name);
3814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3815                         } else {
3816                                 r->document_name = NULL;
3817                         }
3818                         ndr->flags = _flags_save_string;
3819                 }
3820                 {
3821                         uint32_t _flags_save_string = ndr->flags;
3822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3824                         if (_ptr_notify_name) {
3825                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3827                         } else {
3828                                 r->notify_name = NULL;
3829                         }
3830                         ndr->flags = _flags_save_string;
3831                 }
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_data_type));
3836                         if (_ptr_data_type) {
3837                                 NDR_PULL_ALLOC(ndr, r->data_type);
3838                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3839                         } else {
3840                                 r->data_type = 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_print_processor));
3848                         if (_ptr_print_processor) {
3849                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3850                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3851                         } else {
3852                                 r->print_processor = 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_parameters));
3860                         if (_ptr_parameters) {
3861                                 NDR_PULL_ALLOC(ndr, r->parameters);
3862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3863                         } else {
3864                                 r->parameters = 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_driver_name));
3872                         if (_ptr_driver_name) {
3873                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3874                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3875                         } else {
3876                                 r->driver_name = NULL;
3877                         }
3878                         ndr->flags = _flags_save_string;
3879                 }
3880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3881                 if (_ptr_devmode) {
3882                         NDR_PULL_ALLOC(ndr, r->devmode);
3883                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3884                 } else {
3885                         r->devmode = NULL;
3886                 }
3887                 {
3888                         uint32_t _flags_save_string = ndr->flags;
3889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3891                         if (_ptr_text_status) {
3892                                 NDR_PULL_ALLOC(ndr, r->text_status);
3893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3894                         } else {
3895                                 r->text_status = NULL;
3896                         }
3897                         ndr->flags = _flags_save_string;
3898                 }
3899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3900                 if (_ptr_secdesc) {
3901                         NDR_PULL_ALLOC(ndr, r->secdesc);
3902                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3903                 } else {
3904                         r->secdesc = NULL;
3905                 }
3906                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3913                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3917         }
3918         if (ndr_flags & NDR_BUFFERS) {
3919                 {
3920                         uint32_t _flags_save_string = ndr->flags;
3921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3922                         if (r->printer_name) {
3923                                 uint32_t _relative_save_offset;
3924                                 _relative_save_offset = ndr->offset;
3925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3926                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3927                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3930                                 ndr->offset = _relative_save_offset;
3931                         }
3932                         ndr->flags = _flags_save_string;
3933                 }
3934                 {
3935                         uint32_t _flags_save_string = ndr->flags;
3936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3937                         if (r->server_name) {
3938                                 uint32_t _relative_save_offset;
3939                                 _relative_save_offset = ndr->offset;
3940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3941                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3945                                 ndr->offset = _relative_save_offset;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 {
3950                         uint32_t _flags_save_string = ndr->flags;
3951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3952                         if (r->user_name) {
3953                                 uint32_t _relative_save_offset;
3954                                 _relative_save_offset = ndr->offset;
3955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3956                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3957                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3960                                 ndr->offset = _relative_save_offset;
3961                         }
3962                         ndr->flags = _flags_save_string;
3963                 }
3964                 {
3965                         uint32_t _flags_save_string = ndr->flags;
3966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3967                         if (r->document_name) {
3968                                 uint32_t _relative_save_offset;
3969                                 _relative_save_offset = ndr->offset;
3970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3971                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3975                                 ndr->offset = _relative_save_offset;
3976                         }
3977                         ndr->flags = _flags_save_string;
3978                 }
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->notify_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3986                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_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->data_type) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4001                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_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->print_processor) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4016                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_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->parameters) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4031                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_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->driver_name) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4046                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4050                                 ndr->offset = _relative_save_offset;
4051                         }
4052                         ndr->flags = _flags_save_string;
4053                 }
4054                 if (r->devmode) {
4055                         uint32_t _relative_save_offset;
4056                         _relative_save_offset = ndr->offset;
4057                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4058                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4059                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4060                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4062                         ndr->offset = _relative_save_offset;
4063                 }
4064                 {
4065                         uint32_t _flags_save_string = ndr->flags;
4066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4067                         if (r->text_status) {
4068                                 uint32_t _relative_save_offset;
4069                                 _relative_save_offset = ndr->offset;
4070                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4071                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4072                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4073                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4074                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4075                                 ndr->offset = _relative_save_offset;
4076                         }
4077                         ndr->flags = _flags_save_string;
4078                 }
4079                 if (r->secdesc) {
4080                         uint32_t _relative_save_offset;
4081                         _relative_save_offset = ndr->offset;
4082                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4083                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4084                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4085                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4096         ndr->depth++;
4097         ndr_print_uint32(ndr, "job_id", r->job_id);
4098         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4099         ndr->depth++;
4100         if (r->printer_name) {
4101                 ndr_print_string(ndr, "printer_name", r->printer_name);
4102         }
4103         ndr->depth--;
4104         ndr_print_ptr(ndr, "server_name", r->server_name);
4105         ndr->depth++;
4106         if (r->server_name) {
4107                 ndr_print_string(ndr, "server_name", r->server_name);
4108         }
4109         ndr->depth--;
4110         ndr_print_ptr(ndr, "user_name", r->user_name);
4111         ndr->depth++;
4112         if (r->user_name) {
4113                 ndr_print_string(ndr, "user_name", r->user_name);
4114         }
4115         ndr->depth--;
4116         ndr_print_ptr(ndr, "document_name", r->document_name);
4117         ndr->depth++;
4118         if (r->document_name) {
4119                 ndr_print_string(ndr, "document_name", r->document_name);
4120         }
4121         ndr->depth--;
4122         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4123         ndr->depth++;
4124         if (r->notify_name) {
4125                 ndr_print_string(ndr, "notify_name", r->notify_name);
4126         }
4127         ndr->depth--;
4128         ndr_print_ptr(ndr, "data_type", r->data_type);
4129         ndr->depth++;
4130         if (r->data_type) {
4131                 ndr_print_string(ndr, "data_type", r->data_type);
4132         }
4133         ndr->depth--;
4134         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4135         ndr->depth++;
4136         if (r->print_processor) {
4137                 ndr_print_string(ndr, "print_processor", r->print_processor);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "parameters", r->parameters);
4141         ndr->depth++;
4142         if (r->parameters) {
4143                 ndr_print_string(ndr, "parameters", r->parameters);
4144         }
4145         ndr->depth--;
4146         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4147         ndr->depth++;
4148         if (r->driver_name) {
4149                 ndr_print_string(ndr, "driver_name", r->driver_name);
4150         }
4151         ndr->depth--;
4152         ndr_print_ptr(ndr, "devmode", r->devmode);
4153         ndr->depth++;
4154         if (r->devmode) {
4155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4156         }
4157         ndr->depth--;
4158         ndr_print_ptr(ndr, "text_status", r->text_status);
4159         ndr->depth++;
4160         if (r->text_status) {
4161                 ndr_print_string(ndr, "text_status", r->text_status);
4162         }
4163         ndr->depth--;
4164         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4165         ndr->depth++;
4166         if (r->secdesc) {
4167                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4168         }
4169         ndr->depth--;
4170         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4171         ndr_print_uint32(ndr, "priority", r->priority);
4172         ndr_print_uint32(ndr, "position", r->position);
4173         ndr_print_uint32(ndr, "start_time", r->start_time);
4174         ndr_print_uint32(ndr, "until_time", r->until_time);
4175         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4176         ndr_print_uint32(ndr, "size", r->size);
4177         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4178         ndr_print_uint32(ndr, "time", r->time);
4179         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4180         ndr_print_uint32(ndr, "size_high", r->size_high);
4181         ndr->depth--;
4182 }
4183
4184 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4185 {
4186         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4187         if (ndr_flags & NDR_SCALARS) {
4188                 int level = ndr_push_get_switch_value(ndr, r);
4189                 switch (level) {
4190                         case 1: {
4191                                 NDR_CHECK(ndr_push_align(ndr, 4));
4192                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4193                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4194                         break; }
4195
4196                         case 2: {
4197                                 NDR_CHECK(ndr_push_align(ndr, 4));
4198                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4199                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4200                         break; }
4201
4202                         case 3: {
4203                                 NDR_CHECK(ndr_push_align(ndr, 4));
4204                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4205                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4206                         break; }
4207
4208                         case 4: {
4209                                 NDR_CHECK(ndr_push_align(ndr, 4));
4210                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4211                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4212                         break; }
4213
4214                         default: {
4215                         break; }
4216
4217                 }
4218         }
4219         if (ndr_flags & NDR_BUFFERS) {
4220                 int level = ndr_push_get_switch_value(ndr, r);
4221                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4222                 switch (level) {
4223                         case 1:
4224                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4225                         break;
4226
4227                         case 2:
4228                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4229                         break;
4230
4231                         case 3:
4232                         break;
4233
4234                         case 4:
4235                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4236                         break;
4237
4238                         default:
4239                         break;
4240
4241                 }
4242         }
4243         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4248 {
4249         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4250         int level;
4251         level = ndr_pull_get_switch_value(ndr, r);
4252         if (ndr_flags & NDR_SCALARS) {
4253                 switch (level) {
4254                         case 1: {
4255                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4256                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4257                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4258                         break; }
4259
4260                         case 2: {
4261                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4262                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4263                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4264                         break; }
4265
4266                         case 3: {
4267                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4268                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4269                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4270                         break; }
4271
4272                         case 4: {
4273                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4274                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4275                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4276                         break; }
4277
4278                         default: {
4279                         break; }
4280
4281                 }
4282         }
4283         if (ndr_flags & NDR_BUFFERS) {
4284                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4285                 switch (level) {
4286                         case 1:
4287                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4288                         break;
4289
4290                         case 2:
4291                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4292                         break;
4293
4294                         case 3:
4295                         break;
4296
4297                         case 4:
4298                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4299                         break;
4300
4301                         default:
4302                         break;
4303
4304                 }
4305         }
4306         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4307         return NDR_ERR_SUCCESS;
4308 }
4309
4310 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4311 {
4312         int level;
4313         level = ndr_print_get_switch_value(ndr, r);
4314         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4315         switch (level) {
4316                 case 1:
4317                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4318                 break;
4319
4320                 case 2:
4321                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4322                 break;
4323
4324                 case 3:
4325                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4326                 break;
4327
4328                 case 4:
4329                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4330                 break;
4331
4332                 default:
4333                 break;
4334
4335         }
4336 }
4337
4338 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4339 {
4340         if (ndr_flags & NDR_SCALARS) {
4341                 NDR_CHECK(ndr_push_align(ndr, 4));
4342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4346                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4349                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4354                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4355         }
4356         if (ndr_flags & NDR_BUFFERS) {
4357                 if (r->printer_name) {
4358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4361                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4362                 }
4363                 if (r->server_name) {
4364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4368                 }
4369                 if (r->user_name) {
4370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4371                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4372                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4374                 }
4375                 if (r->document_name) {
4376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4379                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4380                 }
4381                 if (r->data_type) {
4382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4385                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4386                 }
4387                 if (r->text_status) {
4388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4391                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4392                 }
4393         }
4394         return NDR_ERR_SUCCESS;
4395 }
4396
4397 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4398 {
4399         uint32_t _ptr_printer_name;
4400         TALLOC_CTX *_mem_save_printer_name_0;
4401         uint32_t _ptr_server_name;
4402         TALLOC_CTX *_mem_save_server_name_0;
4403         uint32_t _ptr_user_name;
4404         TALLOC_CTX *_mem_save_user_name_0;
4405         uint32_t _ptr_document_name;
4406         TALLOC_CTX *_mem_save_document_name_0;
4407         uint32_t _ptr_data_type;
4408         TALLOC_CTX *_mem_save_data_type_0;
4409         uint32_t _ptr_text_status;
4410         TALLOC_CTX *_mem_save_text_status_0;
4411         if (ndr_flags & NDR_SCALARS) {
4412                 NDR_CHECK(ndr_pull_align(ndr, 4));
4413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4415                 if (_ptr_printer_name) {
4416                         NDR_PULL_ALLOC(ndr, r->printer_name);
4417                 } else {
4418                         r->printer_name = NULL;
4419                 }
4420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4421                 if (_ptr_server_name) {
4422                         NDR_PULL_ALLOC(ndr, r->server_name);
4423                 } else {
4424                         r->server_name = NULL;
4425                 }
4426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4427                 if (_ptr_user_name) {
4428                         NDR_PULL_ALLOC(ndr, r->user_name);
4429                 } else {
4430                         r->user_name = NULL;
4431                 }
4432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4433                 if (_ptr_document_name) {
4434                         NDR_PULL_ALLOC(ndr, r->document_name);
4435                 } else {
4436                         r->document_name = NULL;
4437                 }
4438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4439                 if (_ptr_data_type) {
4440                         NDR_PULL_ALLOC(ndr, r->data_type);
4441                 } else {
4442                         r->data_type = NULL;
4443                 }
4444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4445                 if (_ptr_text_status) {
4446                         NDR_PULL_ALLOC(ndr, r->text_status);
4447                 } else {
4448                         r->text_status = NULL;
4449                 }
4450                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4455                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4456         }
4457         if (ndr_flags & NDR_BUFFERS) {
4458                 if (r->printer_name) {
4459                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4460                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4461                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4462                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4463                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4464                                 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));
4465                         }
4466                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4467                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4469                 }
4470                 if (r->server_name) {
4471                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4472                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4474                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4475                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4476                                 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));
4477                         }
4478                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4479                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4481                 }
4482                 if (r->user_name) {
4483                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4484                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4487                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4488                                 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));
4489                         }
4490                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4493                 }
4494                 if (r->document_name) {
4495                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4496                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4499                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4500                                 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));
4501                         }
4502                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4505                 }
4506                 if (r->data_type) {
4507                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4508                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4511                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4512                                 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));
4513                         }
4514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4517                 }
4518                 if (r->text_status) {
4519                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4520                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4522                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4523                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4524                                 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));
4525                         }
4526                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4527                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4529                 }
4530         }
4531         return NDR_ERR_SUCCESS;
4532 }
4533
4534 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4535 {
4536         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4537         ndr->depth++;
4538         ndr_print_uint32(ndr, "job_id", r->job_id);
4539         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4540         ndr->depth++;
4541         if (r->printer_name) {
4542                 ndr_print_string(ndr, "printer_name", r->printer_name);
4543         }
4544         ndr->depth--;
4545         ndr_print_ptr(ndr, "server_name", r->server_name);
4546         ndr->depth++;
4547         if (r->server_name) {
4548                 ndr_print_string(ndr, "server_name", r->server_name);
4549         }
4550         ndr->depth--;
4551         ndr_print_ptr(ndr, "user_name", r->user_name);
4552         ndr->depth++;
4553         if (r->user_name) {
4554                 ndr_print_string(ndr, "user_name", r->user_name);
4555         }
4556         ndr->depth--;
4557         ndr_print_ptr(ndr, "document_name", r->document_name);
4558         ndr->depth++;
4559         if (r->document_name) {
4560                 ndr_print_string(ndr, "document_name", r->document_name);
4561         }
4562         ndr->depth--;
4563         ndr_print_ptr(ndr, "data_type", r->data_type);
4564         ndr->depth++;
4565         if (r->data_type) {
4566                 ndr_print_string(ndr, "data_type", r->data_type);
4567         }
4568         ndr->depth--;
4569         ndr_print_ptr(ndr, "text_status", r->text_status);
4570         ndr->depth++;
4571         if (r->text_status) {
4572                 ndr_print_string(ndr, "text_status", r->text_status);
4573         }
4574         ndr->depth--;
4575         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4576         ndr_print_uint32(ndr, "priority", r->priority);
4577         ndr_print_uint32(ndr, "position", r->position);
4578         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4579         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4580         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4581         ndr->depth--;
4582 }
4583
4584 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4585 {
4586         if (ndr_flags & NDR_SCALARS) {
4587                 NDR_CHECK(ndr_push_align(ndr, 4));
4588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4589                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4591                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4592                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4595                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4596                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4601                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4608                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4611         }
4612         if (ndr_flags & NDR_BUFFERS) {
4613                 if (r->printer_name) {
4614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4617                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4618                 }
4619                 if (r->server_name) {
4620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4624                 }
4625                 if (r->user_name) {
4626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4629                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4630                 }
4631                 if (r->document_name) {
4632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4635                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4636                 }
4637                 if (r->notify_name) {
4638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4641                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4642                 }
4643                 if (r->data_type) {
4644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4645                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4646                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4647                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4648                 }
4649                 if (r->print_processor) {
4650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4653                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4654                 }
4655                 if (r->parameters) {
4656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4659                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4660                 }
4661                 if (r->driver_name) {
4662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4665                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4666                 }
4667                 if (r->text_status) {
4668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4671                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4672                 }
4673         }
4674         return NDR_ERR_SUCCESS;
4675 }
4676
4677 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4678 {
4679         uint32_t _ptr_printer_name;
4680         TALLOC_CTX *_mem_save_printer_name_0;
4681         uint32_t _ptr_server_name;
4682         TALLOC_CTX *_mem_save_server_name_0;
4683         uint32_t _ptr_user_name;
4684         TALLOC_CTX *_mem_save_user_name_0;
4685         uint32_t _ptr_document_name;
4686         TALLOC_CTX *_mem_save_document_name_0;
4687         uint32_t _ptr_notify_name;
4688         TALLOC_CTX *_mem_save_notify_name_0;
4689         uint32_t _ptr_data_type;
4690         TALLOC_CTX *_mem_save_data_type_0;
4691         uint32_t _ptr_print_processor;
4692         TALLOC_CTX *_mem_save_print_processor_0;
4693         uint32_t _ptr_parameters;
4694         TALLOC_CTX *_mem_save_parameters_0;
4695         uint32_t _ptr_driver_name;
4696         TALLOC_CTX *_mem_save_driver_name_0;
4697         uint32_t _ptr_text_status;
4698         TALLOC_CTX *_mem_save_text_status_0;
4699         if (ndr_flags & NDR_SCALARS) {
4700                 NDR_CHECK(ndr_pull_align(ndr, 4));
4701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4703                 if (_ptr_printer_name) {
4704                         NDR_PULL_ALLOC(ndr, r->printer_name);
4705                 } else {
4706                         r->printer_name = NULL;
4707                 }
4708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4709                 if (_ptr_server_name) {
4710                         NDR_PULL_ALLOC(ndr, r->server_name);
4711                 } else {
4712                         r->server_name = NULL;
4713                 }
4714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4715                 if (_ptr_user_name) {
4716                         NDR_PULL_ALLOC(ndr, r->user_name);
4717                 } else {
4718                         r->user_name = NULL;
4719                 }
4720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4721                 if (_ptr_document_name) {
4722                         NDR_PULL_ALLOC(ndr, r->document_name);
4723                 } else {
4724                         r->document_name = NULL;
4725                 }
4726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4727                 if (_ptr_notify_name) {
4728                         NDR_PULL_ALLOC(ndr, r->notify_name);
4729                 } else {
4730                         r->notify_name = NULL;
4731                 }
4732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4733                 if (_ptr_data_type) {
4734                         NDR_PULL_ALLOC(ndr, r->data_type);
4735                 } else {
4736                         r->data_type = NULL;
4737                 }
4738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4739                 if (_ptr_print_processor) {
4740                         NDR_PULL_ALLOC(ndr, r->print_processor);
4741                 } else {
4742                         r->print_processor = NULL;
4743                 }
4744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4745                 if (_ptr_parameters) {
4746                         NDR_PULL_ALLOC(ndr, r->parameters);
4747                 } else {
4748                         r->parameters = NULL;
4749                 }
4750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4751                 if (_ptr_driver_name) {
4752                         NDR_PULL_ALLOC(ndr, r->driver_name);
4753                 } else {
4754                         r->driver_name = NULL;
4755                 }
4756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4758                 if (_ptr_text_status) {
4759                         NDR_PULL_ALLOC(ndr, r->text_status);
4760                 } else {
4761                         r->text_status = NULL;
4762                 }
4763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4764                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4771                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4774         }
4775         if (ndr_flags & NDR_BUFFERS) {
4776                 if (r->printer_name) {
4777                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4778                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4780                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4781                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4782                                 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));
4783                         }
4784                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4785                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4787                 }
4788                 if (r->server_name) {
4789                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4790                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4793                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4794                                 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));
4795                         }
4796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4799                 }
4800                 if (r->user_name) {
4801                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4802                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4805                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4806                                 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));
4807                         }
4808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4811                 }
4812                 if (r->document_name) {
4813                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4814                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4817                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4818                                 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));
4819                         }
4820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4823                 }
4824                 if (r->notify_name) {
4825                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4826                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4828                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4829                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4830                                 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));
4831                         }
4832                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4835                 }
4836                 if (r->data_type) {
4837                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4838                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4840                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4841                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4842                                 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));
4843                         }
4844                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4845                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4847                 }
4848                 if (r->print_processor) {
4849                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4850                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4853                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4854                                 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));
4855                         }
4856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4859                 }
4860                 if (r->parameters) {
4861                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4862                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4865                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4866                                 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));
4867                         }
4868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4871                 }
4872                 if (r->driver_name) {
4873                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4874                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4877                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4878                                 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));
4879                         }
4880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4883                 }
4884                 if (r->text_status) {
4885                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4886                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4889                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4890                                 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));
4891                         }
4892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4895                 }
4896         }
4897         return NDR_ERR_SUCCESS;
4898 }
4899
4900 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4901 {
4902         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4903         ndr->depth++;
4904         ndr_print_uint32(ndr, "job_id", r->job_id);
4905         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4906         ndr->depth++;
4907         if (r->printer_name) {
4908                 ndr_print_string(ndr, "printer_name", r->printer_name);
4909         }
4910         ndr->depth--;
4911         ndr_print_ptr(ndr, "server_name", r->server_name);
4912         ndr->depth++;
4913         if (r->server_name) {
4914                 ndr_print_string(ndr, "server_name", r->server_name);
4915         }
4916         ndr->depth--;
4917         ndr_print_ptr(ndr, "user_name", r->user_name);
4918         ndr->depth++;
4919         if (r->user_name) {
4920                 ndr_print_string(ndr, "user_name", r->user_name);
4921         }
4922         ndr->depth--;
4923         ndr_print_ptr(ndr, "document_name", r->document_name);
4924         ndr->depth++;
4925         if (r->document_name) {
4926                 ndr_print_string(ndr, "document_name", r->document_name);
4927         }
4928         ndr->depth--;
4929         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4930         ndr->depth++;
4931         if (r->notify_name) {
4932                 ndr_print_string(ndr, "notify_name", r->notify_name);
4933         }
4934         ndr->depth--;
4935         ndr_print_ptr(ndr, "data_type", r->data_type);
4936         ndr->depth++;
4937         if (r->data_type) {
4938                 ndr_print_string(ndr, "data_type", r->data_type);
4939         }
4940         ndr->depth--;
4941         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4942         ndr->depth++;
4943         if (r->print_processor) {
4944                 ndr_print_string(ndr, "print_processor", r->print_processor);
4945         }
4946         ndr->depth--;
4947         ndr_print_ptr(ndr, "parameters", r->parameters);
4948         ndr->depth++;
4949         if (r->parameters) {
4950                 ndr_print_string(ndr, "parameters", r->parameters);
4951         }
4952         ndr->depth--;
4953         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4954         ndr->depth++;
4955         if (r->driver_name) {
4956                 ndr_print_string(ndr, "driver_name", r->driver_name);
4957         }
4958         ndr->depth--;
4959         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
4960         ndr_print_ptr(ndr, "text_status", r->text_status);
4961         ndr->depth++;
4962         if (r->text_status) {
4963                 ndr_print_string(ndr, "text_status", r->text_status);
4964         }
4965         ndr->depth--;
4966         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
4967         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4968         ndr_print_uint32(ndr, "priority", r->priority);
4969         ndr_print_uint32(ndr, "position", r->position);
4970         ndr_print_uint32(ndr, "start_time", r->start_time);
4971         ndr_print_uint32(ndr, "until_time", r->until_time);
4972         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4973         ndr_print_uint32(ndr, "size", r->size);
4974         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4975         ndr_print_uint32(ndr, "time", r->time);
4976         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4977         ndr->depth--;
4978 }
4979
4980 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
4981 {
4982         if (ndr_flags & NDR_SCALARS) {
4983                 NDR_CHECK(ndr_push_align(ndr, 4));
4984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4997                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5002                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5004                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5008         }
5009         if (ndr_flags & NDR_BUFFERS) {
5010                 if (r->printer_name) {
5011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5014                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5015                 }
5016                 if (r->server_name) {
5017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5021                 }
5022                 if (r->user_name) {
5023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5027                 }
5028                 if (r->document_name) {
5029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5033                 }
5034                 if (r->notify_name) {
5035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5038                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5039                 }
5040                 if (r->data_type) {
5041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5044                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5045                 }
5046                 if (r->print_processor) {
5047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5051                 }
5052                 if (r->parameters) {
5053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5057                 }
5058                 if (r->driver_name) {
5059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5063                 }
5064                 if (r->text_status) {
5065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5069                 }
5070         }
5071         return NDR_ERR_SUCCESS;
5072 }
5073
5074 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5075 {
5076         uint32_t _ptr_printer_name;
5077         TALLOC_CTX *_mem_save_printer_name_0;
5078         uint32_t _ptr_server_name;
5079         TALLOC_CTX *_mem_save_server_name_0;
5080         uint32_t _ptr_user_name;
5081         TALLOC_CTX *_mem_save_user_name_0;
5082         uint32_t _ptr_document_name;
5083         TALLOC_CTX *_mem_save_document_name_0;
5084         uint32_t _ptr_notify_name;
5085         TALLOC_CTX *_mem_save_notify_name_0;
5086         uint32_t _ptr_data_type;
5087         TALLOC_CTX *_mem_save_data_type_0;
5088         uint32_t _ptr_print_processor;
5089         TALLOC_CTX *_mem_save_print_processor_0;
5090         uint32_t _ptr_parameters;
5091         TALLOC_CTX *_mem_save_parameters_0;
5092         uint32_t _ptr_driver_name;
5093         TALLOC_CTX *_mem_save_driver_name_0;
5094         uint32_t _ptr_text_status;
5095         TALLOC_CTX *_mem_save_text_status_0;
5096         if (ndr_flags & NDR_SCALARS) {
5097                 NDR_CHECK(ndr_pull_align(ndr, 4));
5098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5100                 if (_ptr_printer_name) {
5101                         NDR_PULL_ALLOC(ndr, r->printer_name);
5102                 } else {
5103                         r->printer_name = NULL;
5104                 }
5105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5106                 if (_ptr_server_name) {
5107                         NDR_PULL_ALLOC(ndr, r->server_name);
5108                 } else {
5109                         r->server_name = NULL;
5110                 }
5111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5112                 if (_ptr_user_name) {
5113                         NDR_PULL_ALLOC(ndr, r->user_name);
5114                 } else {
5115                         r->user_name = NULL;
5116                 }
5117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5118                 if (_ptr_document_name) {
5119                         NDR_PULL_ALLOC(ndr, r->document_name);
5120                 } else {
5121                         r->document_name = NULL;
5122                 }
5123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5124                 if (_ptr_notify_name) {
5125                         NDR_PULL_ALLOC(ndr, r->notify_name);
5126                 } else {
5127                         r->notify_name = NULL;
5128                 }
5129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5130                 if (_ptr_data_type) {
5131                         NDR_PULL_ALLOC(ndr, r->data_type);
5132                 } else {
5133                         r->data_type = NULL;
5134                 }
5135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5136                 if (_ptr_print_processor) {
5137                         NDR_PULL_ALLOC(ndr, r->print_processor);
5138                 } else {
5139                         r->print_processor = NULL;
5140                 }
5141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5142                 if (_ptr_parameters) {
5143                         NDR_PULL_ALLOC(ndr, r->parameters);
5144                 } else {
5145                         r->parameters = NULL;
5146                 }
5147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5148                 if (_ptr_driver_name) {
5149                         NDR_PULL_ALLOC(ndr, r->driver_name);
5150                 } else {
5151                         r->driver_name = NULL;
5152                 }
5153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5155                 if (_ptr_text_status) {
5156                         NDR_PULL_ALLOC(ndr, r->text_status);
5157                 } else {
5158                         r->text_status = NULL;
5159                 }
5160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5161                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5168                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5172         }
5173         if (ndr_flags & NDR_BUFFERS) {
5174                 if (r->printer_name) {
5175                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5176                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5178                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5179                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5180                                 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));
5181                         }
5182                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5183                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5185                 }
5186                 if (r->server_name) {
5187                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5188                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5191                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5192                                 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));
5193                         }
5194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5197                 }
5198                 if (r->user_name) {
5199                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5200                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5203                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5204                                 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));
5205                         }
5206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5209                 }
5210                 if (r->document_name) {
5211                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5212                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5213                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5214                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5215                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5216                                 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));
5217                         }
5218                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5219                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5221                 }
5222                 if (r->notify_name) {
5223                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5224                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5225                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5226                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5227                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5228                                 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));
5229                         }
5230                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5231                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5233                 }
5234                 if (r->data_type) {
5235                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5236                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5237                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5238                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5239                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5240                                 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));
5241                         }
5242                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5243                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5245                 }
5246                 if (r->print_processor) {
5247                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5248                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5249                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5250                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5251                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5252                                 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));
5253                         }
5254                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5255                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5257                 }
5258                 if (r->parameters) {
5259                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5260                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5261                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5262                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5263                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5264                                 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));
5265                         }
5266                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5267                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5268                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5269                 }
5270                 if (r->driver_name) {
5271                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5272                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5273                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5274                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5275                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5276                                 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));
5277                         }
5278                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5279                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5281                 }
5282                 if (r->text_status) {
5283                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5284                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5287                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5288                                 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));
5289                         }
5290                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5291                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5293                 }
5294         }
5295         return NDR_ERR_SUCCESS;
5296 }
5297
5298 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5299 {
5300         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5301         ndr->depth++;
5302         ndr_print_uint32(ndr, "job_id", r->job_id);
5303         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5304         ndr->depth++;
5305         if (r->printer_name) {
5306                 ndr_print_string(ndr, "printer_name", r->printer_name);
5307         }
5308         ndr->depth--;
5309         ndr_print_ptr(ndr, "server_name", r->server_name);
5310         ndr->depth++;
5311         if (r->server_name) {
5312                 ndr_print_string(ndr, "server_name", r->server_name);
5313         }
5314         ndr->depth--;
5315         ndr_print_ptr(ndr, "user_name", r->user_name);
5316         ndr->depth++;
5317         if (r->user_name) {
5318                 ndr_print_string(ndr, "user_name", r->user_name);
5319         }
5320         ndr->depth--;
5321         ndr_print_ptr(ndr, "document_name", r->document_name);
5322         ndr->depth++;
5323         if (r->document_name) {
5324                 ndr_print_string(ndr, "document_name", r->document_name);
5325         }
5326         ndr->depth--;
5327         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5328         ndr->depth++;
5329         if (r->notify_name) {
5330                 ndr_print_string(ndr, "notify_name", r->notify_name);
5331         }
5332         ndr->depth--;
5333         ndr_print_ptr(ndr, "data_type", r->data_type);
5334         ndr->depth++;
5335         if (r->data_type) {
5336                 ndr_print_string(ndr, "data_type", r->data_type);
5337         }
5338         ndr->depth--;
5339         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5340         ndr->depth++;
5341         if (r->print_processor) {
5342                 ndr_print_string(ndr, "print_processor", r->print_processor);
5343         }
5344         ndr->depth--;
5345         ndr_print_ptr(ndr, "parameters", r->parameters);
5346         ndr->depth++;
5347         if (r->parameters) {
5348                 ndr_print_string(ndr, "parameters", r->parameters);
5349         }
5350         ndr->depth--;
5351         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5352         ndr->depth++;
5353         if (r->driver_name) {
5354                 ndr_print_string(ndr, "driver_name", r->driver_name);
5355         }
5356         ndr->depth--;
5357         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5358         ndr_print_ptr(ndr, "text_status", r->text_status);
5359         ndr->depth++;
5360         if (r->text_status) {
5361                 ndr_print_string(ndr, "text_status", r->text_status);
5362         }
5363         ndr->depth--;
5364         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5365         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5366         ndr_print_uint32(ndr, "priority", r->priority);
5367         ndr_print_uint32(ndr, "position", r->position);
5368         ndr_print_uint32(ndr, "start_time", r->start_time);
5369         ndr_print_uint32(ndr, "until_time", r->until_time);
5370         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5371         ndr_print_uint32(ndr, "size", r->size);
5372         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5373         ndr_print_uint32(ndr, "time", r->time);
5374         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5375         ndr_print_uint32(ndr, "size_high", r->size_high);
5376         ndr->depth--;
5377 }
5378
5379 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5380 {
5381         if (ndr_flags & NDR_SCALARS) {
5382                 int level = ndr_push_get_switch_value(ndr, r);
5383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5384                 switch (level) {
5385                         case 1: {
5386                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5387                         break; }
5388
5389                         case 2: {
5390                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5391                         break; }
5392
5393                         case 3: {
5394                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5395                         break; }
5396
5397                         case 4: {
5398                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5399                         break; }
5400
5401                         default: {
5402                         break; }
5403
5404                 }
5405         }
5406         if (ndr_flags & NDR_BUFFERS) {
5407                 int level = ndr_push_get_switch_value(ndr, r);
5408                 switch (level) {
5409                         case 1:
5410                                 if (r->info1) {
5411                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5412                                 }
5413                         break;
5414
5415                         case 2:
5416                                 if (r->info2) {
5417                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5418                                 }
5419                         break;
5420
5421                         case 3:
5422                                 if (r->info3) {
5423                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5424                                 }
5425                         break;
5426
5427                         case 4:
5428                                 if (r->info4) {
5429                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5430                                 }
5431                         break;
5432
5433                         default:
5434                         break;
5435
5436                 }
5437         }
5438         return NDR_ERR_SUCCESS;
5439 }
5440
5441 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5442 {
5443         int level;
5444         uint32_t _level;
5445         TALLOC_CTX *_mem_save_info1_0;
5446         TALLOC_CTX *_mem_save_info2_0;
5447         TALLOC_CTX *_mem_save_info3_0;
5448         TALLOC_CTX *_mem_save_info4_0;
5449         level = ndr_pull_get_switch_value(ndr, r);
5450         if (ndr_flags & NDR_SCALARS) {
5451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5452                 if (_level != level) {
5453                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5454                 }
5455                 switch (level) {
5456                         case 1: {
5457                                 uint32_t _ptr_info1;
5458                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5459                                 if (_ptr_info1) {
5460                                         NDR_PULL_ALLOC(ndr, r->info1);
5461                                 } else {
5462                                         r->info1 = NULL;
5463                                 }
5464                         break; }
5465
5466                         case 2: {
5467                                 uint32_t _ptr_info2;
5468                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5469                                 if (_ptr_info2) {
5470                                         NDR_PULL_ALLOC(ndr, r->info2);
5471                                 } else {
5472                                         r->info2 = NULL;
5473                                 }
5474                         break; }
5475
5476                         case 3: {
5477                                 uint32_t _ptr_info3;
5478                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5479                                 if (_ptr_info3) {
5480                                         NDR_PULL_ALLOC(ndr, r->info3);
5481                                 } else {
5482                                         r->info3 = NULL;
5483                                 }
5484                         break; }
5485
5486                         case 4: {
5487                                 uint32_t _ptr_info4;
5488                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5489                                 if (_ptr_info4) {
5490                                         NDR_PULL_ALLOC(ndr, r->info4);
5491                                 } else {
5492                                         r->info4 = NULL;
5493                                 }
5494                         break; }
5495
5496                         default: {
5497                         break; }
5498
5499                 }
5500         }
5501         if (ndr_flags & NDR_BUFFERS) {
5502                 switch (level) {
5503                         case 1:
5504                                 if (r->info1) {
5505                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5506                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5507                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5508                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5509                                 }
5510                         break;
5511
5512                         case 2:
5513                                 if (r->info2) {
5514                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5515                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5516                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5517                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5518                                 }
5519                         break;
5520
5521                         case 3:
5522                                 if (r->info3) {
5523                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5524                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5525                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5526                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5527                                 }
5528                         break;
5529
5530                         case 4:
5531                                 if (r->info4) {
5532                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5533                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5534                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5535                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5536                                 }
5537                         break;
5538
5539                         default:
5540                         break;
5541
5542                 }
5543         }
5544         return NDR_ERR_SUCCESS;
5545 }
5546
5547 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5548 {
5549         int level;
5550         level = ndr_print_get_switch_value(ndr, r);
5551         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5552         switch (level) {
5553                 case 1:
5554                         ndr_print_ptr(ndr, "info1", r->info1);
5555                         ndr->depth++;
5556                         if (r->info1) {
5557                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5558                         }
5559                         ndr->depth--;
5560                 break;
5561
5562                 case 2:
5563                         ndr_print_ptr(ndr, "info2", r->info2);
5564                         ndr->depth++;
5565                         if (r->info2) {
5566                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5567                         }
5568                         ndr->depth--;
5569                 break;
5570
5571                 case 3:
5572                         ndr_print_ptr(ndr, "info3", r->info3);
5573                         ndr->depth++;
5574                         if (r->info3) {
5575                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5576                         }
5577                         ndr->depth--;
5578                 break;
5579
5580                 case 4:
5581                         ndr_print_ptr(ndr, "info4", r->info4);
5582                         ndr->depth++;
5583                         if (r->info4) {
5584                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5585                         }
5586                         ndr->depth--;
5587                 break;
5588
5589                 default:
5590                 break;
5591
5592         }
5593 }
5594
5595 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5596 {
5597         if (ndr_flags & NDR_SCALARS) {
5598                 NDR_CHECK(ndr_push_align(ndr, 4));
5599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5600                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5601                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5602         }
5603         if (ndr_flags & NDR_BUFFERS) {
5604                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5605         }
5606         return NDR_ERR_SUCCESS;
5607 }
5608
5609 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5610 {
5611         if (ndr_flags & NDR_SCALARS) {
5612                 NDR_CHECK(ndr_pull_align(ndr, 4));
5613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5614                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5615                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5616         }
5617         if (ndr_flags & NDR_BUFFERS) {
5618                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5619         }
5620         return NDR_ERR_SUCCESS;
5621 }
5622
5623 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5624 {
5625         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5626         ndr->depth++;
5627         ndr_print_uint32(ndr, "level", r->level);
5628         ndr_print_set_switch_value(ndr, &r->info, r->level);
5629         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5630         ndr->depth--;
5631 }
5632
5633 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5634 {
5635         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5636         return NDR_ERR_SUCCESS;
5637 }
5638
5639 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5640 {
5641         uint32_t v;
5642         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5643         *r = v;
5644         return NDR_ERR_SUCCESS;
5645 }
5646
5647 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5648 {
5649         const char *val = NULL;
5650
5651         switch (r) {
5652                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5653                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5654                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5655                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5656                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5657                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5658                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5659                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5660                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5661         }
5662         ndr_print_enum(ndr, name, "ENUM", val, r);
5663 }
5664
5665 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5666 {
5667         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5668         return NDR_ERR_SUCCESS;
5669 }
5670
5671 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5672 {
5673         uint32_t v;
5674         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5675         *r = v;
5676         return NDR_ERR_SUCCESS;
5677 }
5678
5679 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5680 {
5681         const char *val = NULL;
5682
5683         switch (r) {
5684                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5685                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5686                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5687                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5688                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5689         }
5690         ndr_print_enum(ndr, name, "ENUM", val, r);
5691 }
5692
5693 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5694 {
5695         if (ndr_flags & NDR_SCALARS) {
5696                 NDR_CHECK(ndr_push_align(ndr, 4));
5697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5702                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5714                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5721                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5722                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5726         }
5727         if (ndr_flags & NDR_BUFFERS) {
5728                 if (r->servername) {
5729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5733                 }
5734                 if (r->printername) {
5735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5739                 }
5740         }
5741         return NDR_ERR_SUCCESS;
5742 }
5743
5744 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5745 {
5746         uint32_t _ptr_servername;
5747         TALLOC_CTX *_mem_save_servername_0;
5748         uint32_t _ptr_printername;
5749         TALLOC_CTX *_mem_save_printername_0;
5750         if (ndr_flags & NDR_SCALARS) {
5751                 NDR_CHECK(ndr_pull_align(ndr, 4));
5752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5753                 if (_ptr_servername) {
5754                         NDR_PULL_ALLOC(ndr, r->servername);
5755                 } else {
5756                         r->servername = NULL;
5757                 }
5758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5759                 if (_ptr_printername) {
5760                         NDR_PULL_ALLOC(ndr, r->printername);
5761                 } else {
5762                         r->printername = NULL;
5763                 }
5764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5767                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5779                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5786                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5787                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5791         }
5792         if (ndr_flags & NDR_BUFFERS) {
5793                 if (r->servername) {
5794                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5795                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5797                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5798                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5799                                 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));
5800                         }
5801                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5802                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5804                 }
5805                 if (r->printername) {
5806                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5807                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5810                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5811                                 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));
5812                         }
5813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5814                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5816                 }
5817         }
5818         return NDR_ERR_SUCCESS;
5819 }
5820
5821 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5822 {
5823         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5824         ndr->depth++;
5825         ndr_print_ptr(ndr, "servername", r->servername);
5826         ndr->depth++;
5827         if (r->servername) {
5828                 ndr_print_string(ndr, "servername", r->servername);
5829         }
5830         ndr->depth--;
5831         ndr_print_ptr(ndr, "printername", r->printername);
5832         ndr->depth++;
5833         if (r->printername) {
5834                 ndr_print_string(ndr, "printername", r->printername);
5835         }
5836         ndr->depth--;
5837         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5838         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5839         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5840         ndr_print_spoolss_Time(ndr, "time", &r->time);
5841         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5842         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5843         ndr_print_uint32(ndr, "version", r->version);
5844         ndr_print_uint32(ndr, "free_build", r->free_build);
5845         ndr_print_uint32(ndr, "spooling", r->spooling);
5846         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5847         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5848         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5849         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5850         ndr_print_uint32(ndr, "job_error", r->job_error);
5851         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5852         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5853         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5854         ndr_print_uint32(ndr, "change_id", r->change_id);
5855         ndr_print_WERROR(ndr, "last_error", r->last_error);
5856         ndr_print_uint32(ndr, "status", r->status);
5857         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5858         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5859         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5860         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5861         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5862         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5863         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5864         ndr->depth--;
5865 }
5866
5867 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5868 {
5869         if (ndr_flags & NDR_SCALARS) {
5870                 NDR_CHECK(ndr_push_align(ndr, 4));
5871                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5875         }
5876         if (ndr_flags & NDR_BUFFERS) {
5877                 if (r->name) {
5878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5881                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5882                 }
5883                 if (r->description) {
5884                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5886                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5887                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5888                 }
5889                 if (r->comment) {
5890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5893                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5894                 }
5895         }
5896         return NDR_ERR_SUCCESS;
5897 }
5898
5899 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5900 {
5901         uint32_t _ptr_name;
5902         TALLOC_CTX *_mem_save_name_0;
5903         uint32_t _ptr_description;
5904         TALLOC_CTX *_mem_save_description_0;
5905         uint32_t _ptr_comment;
5906         TALLOC_CTX *_mem_save_comment_0;
5907         if (ndr_flags & NDR_SCALARS) {
5908                 NDR_CHECK(ndr_pull_align(ndr, 4));
5909                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
5910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
5911                 if (_ptr_name) {
5912                         NDR_PULL_ALLOC(ndr, r->name);
5913                 } else {
5914                         r->name = NULL;
5915                 }
5916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
5917                 if (_ptr_description) {
5918                         NDR_PULL_ALLOC(ndr, r->description);
5919                 } else {
5920                         r->description = NULL;
5921                 }
5922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5923                 if (_ptr_comment) {
5924                         NDR_PULL_ALLOC(ndr, r->comment);
5925                 } else {
5926                         r->comment = NULL;
5927                 }
5928         }
5929         if (ndr_flags & NDR_BUFFERS) {
5930                 if (r->name) {
5931                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5932                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
5933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
5934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
5935                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
5936                                 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));
5937                         }
5938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
5939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
5940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
5941                 }
5942                 if (r->description) {
5943                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
5944                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
5945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
5946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
5947                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
5948                                 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));
5949                         }
5950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
5951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
5952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
5953                 }
5954                 if (r->comment) {
5955                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
5956                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
5957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
5958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
5959                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
5960                                 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));
5961                         }
5962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
5963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
5964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
5965                 }
5966         }
5967         return NDR_ERR_SUCCESS;
5968 }
5969
5970 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
5971 {
5972         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
5973         ndr->depth++;
5974         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
5975         ndr_print_ptr(ndr, "name", r->name);
5976         ndr->depth++;
5977         if (r->name) {
5978                 ndr_print_string(ndr, "name", r->name);
5979         }
5980         ndr->depth--;
5981         ndr_print_ptr(ndr, "description", r->description);
5982         ndr->depth++;
5983         if (r->description) {
5984                 ndr_print_string(ndr, "description", r->description);
5985         }
5986         ndr->depth--;
5987         ndr_print_ptr(ndr, "comment", r->comment);
5988         ndr->depth++;
5989         if (r->comment) {
5990                 ndr_print_string(ndr, "comment", r->comment);
5991         }
5992         ndr->depth--;
5993         ndr->depth--;
5994 }
5995
5996 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
5997 {
5998         if (ndr_flags & NDR_SCALARS) {
5999                 NDR_CHECK(ndr_push_align(ndr, 4));
6000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6007                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6009                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6013                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6018                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6021         }
6022         if (ndr_flags & NDR_BUFFERS) {
6023                 if (r->servername) {
6024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6027                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6028                 }
6029                 if (r->printername) {
6030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6034                 }
6035                 if (r->sharename) {
6036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6039                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6040                 }
6041                 if (r->portname) {
6042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6045                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6046                 }
6047                 if (r->drivername) {
6048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6051                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6052                 }
6053                 if (r->comment) {
6054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6058                 }
6059                 if (r->location) {
6060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6063                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6064                 }
6065                 if (r->devmode) {
6066                         {
6067                                 struct ndr_push *_ndr_devmode;
6068                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6069                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6070                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6071                         }
6072                 }
6073                 if (r->sepfile) {
6074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6078                 }
6079                 if (r->printprocessor) {
6080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6084                 }
6085                 if (r->datatype) {
6086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6090                 }
6091                 if (r->parameters) {
6092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6096                 }
6097                 if (r->secdesc) {
6098                         {
6099                                 struct ndr_push *_ndr_secdesc;
6100                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6101                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6102                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6103                         }
6104                 }
6105         }
6106         return NDR_ERR_SUCCESS;
6107 }
6108
6109 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6110 {
6111         uint32_t _ptr_servername;
6112         TALLOC_CTX *_mem_save_servername_0;
6113         uint32_t _ptr_printername;
6114         TALLOC_CTX *_mem_save_printername_0;
6115         uint32_t _ptr_sharename;
6116         TALLOC_CTX *_mem_save_sharename_0;
6117         uint32_t _ptr_portname;
6118         TALLOC_CTX *_mem_save_portname_0;
6119         uint32_t _ptr_drivername;
6120         TALLOC_CTX *_mem_save_drivername_0;
6121         uint32_t _ptr_comment;
6122         TALLOC_CTX *_mem_save_comment_0;
6123         uint32_t _ptr_location;
6124         TALLOC_CTX *_mem_save_location_0;
6125         uint32_t _ptr_devmode;
6126         TALLOC_CTX *_mem_save_devmode_0;
6127         uint32_t _ptr_sepfile;
6128         TALLOC_CTX *_mem_save_sepfile_0;
6129         uint32_t _ptr_printprocessor;
6130         TALLOC_CTX *_mem_save_printprocessor_0;
6131         uint32_t _ptr_datatype;
6132         TALLOC_CTX *_mem_save_datatype_0;
6133         uint32_t _ptr_parameters;
6134         TALLOC_CTX *_mem_save_parameters_0;
6135         uint32_t _ptr_secdesc;
6136         TALLOC_CTX *_mem_save_secdesc_0;
6137         if (ndr_flags & NDR_SCALARS) {
6138                 NDR_CHECK(ndr_pull_align(ndr, 4));
6139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6140                 if (_ptr_servername) {
6141                         NDR_PULL_ALLOC(ndr, r->servername);
6142                 } else {
6143                         r->servername = NULL;
6144                 }
6145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6146                 if (_ptr_printername) {
6147                         NDR_PULL_ALLOC(ndr, r->printername);
6148                 } else {
6149                         r->printername = NULL;
6150                 }
6151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6152                 if (_ptr_sharename) {
6153                         NDR_PULL_ALLOC(ndr, r->sharename);
6154                 } else {
6155                         r->sharename = NULL;
6156                 }
6157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6158                 if (_ptr_portname) {
6159                         NDR_PULL_ALLOC(ndr, r->portname);
6160                 } else {
6161                         r->portname = NULL;
6162                 }
6163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6164                 if (_ptr_drivername) {
6165                         NDR_PULL_ALLOC(ndr, r->drivername);
6166                 } else {
6167                         r->drivername = NULL;
6168                 }
6169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6170                 if (_ptr_comment) {
6171                         NDR_PULL_ALLOC(ndr, r->comment);
6172                 } else {
6173                         r->comment = NULL;
6174                 }
6175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6176                 if (_ptr_location) {
6177                         NDR_PULL_ALLOC(ndr, r->location);
6178                 } else {
6179                         r->location = NULL;
6180                 }
6181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6182                 if (_ptr_devmode) {
6183                         NDR_PULL_ALLOC(ndr, r->devmode);
6184                 } else {
6185                         r->devmode = NULL;
6186                 }
6187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6188                 if (_ptr_sepfile) {
6189                         NDR_PULL_ALLOC(ndr, r->sepfile);
6190                 } else {
6191                         r->sepfile = NULL;
6192                 }
6193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6194                 if (_ptr_printprocessor) {
6195                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6196                 } else {
6197                         r->printprocessor = NULL;
6198                 }
6199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6200                 if (_ptr_datatype) {
6201                         NDR_PULL_ALLOC(ndr, r->datatype);
6202                 } else {
6203                         r->datatype = NULL;
6204                 }
6205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6206                 if (_ptr_parameters) {
6207                         NDR_PULL_ALLOC(ndr, r->parameters);
6208                 } else {
6209                         r->parameters = NULL;
6210                 }
6211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6212                 if (_ptr_secdesc) {
6213                         NDR_PULL_ALLOC(ndr, r->secdesc);
6214                 } else {
6215                         r->secdesc = NULL;
6216                 }
6217                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6222                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6225         }
6226         if (ndr_flags & NDR_BUFFERS) {
6227                 if (r->servername) {
6228                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6229                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6231                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6232                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6233                                 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));
6234                         }
6235                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6236                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6238                 }
6239                 if (r->printername) {
6240                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6241                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6243                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6244                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6245                                 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));
6246                         }
6247                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6248                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6250                 }
6251                 if (r->sharename) {
6252                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6253                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6254                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6255                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6256                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6257                                 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));
6258                         }
6259                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6260                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6262                 }
6263                 if (r->portname) {
6264                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6265                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6268                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6269                                 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));
6270                         }
6271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6274                 }
6275                 if (r->drivername) {
6276                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6280                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6281                                 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));
6282                         }
6283                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6284                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6286                 }
6287                 if (r->comment) {
6288                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6289                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6292                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6293                                 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));
6294                         }
6295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6296                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6298                 }
6299                 if (r->location) {
6300                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6301                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6302                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6303                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6304                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6305                                 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));
6306                         }
6307                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6308                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6310                 }
6311                 if (r->devmode) {
6312                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6313                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6314                         {
6315                                 struct ndr_pull *_ndr_devmode;
6316                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6317                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6318                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6319                         }
6320                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6321                 }
6322                 if (r->sepfile) {
6323                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6324                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6325                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6326                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6327                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6328                                 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));
6329                         }
6330                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6331                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6333                 }
6334                 if (r->printprocessor) {
6335                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6336                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6337                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6338                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6339                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6340                                 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));
6341                         }
6342                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6343                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6344                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6345                 }
6346                 if (r->datatype) {
6347                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6348                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6349                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6350                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6351                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6352                                 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));
6353                         }
6354                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6355                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6356                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6357                 }
6358                 if (r->parameters) {
6359                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6360                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6361                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6362                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6363                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6364                                 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));
6365                         }
6366                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6367                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6368                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6369                 }
6370                 if (r->secdesc) {
6371                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6372                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6373                         {
6374                                 struct ndr_pull *_ndr_secdesc;
6375                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6376                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6377                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6378                         }
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6380                 }
6381         }
6382         return NDR_ERR_SUCCESS;
6383 }
6384
6385 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6386 {
6387         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6388         ndr->depth++;
6389         ndr_print_ptr(ndr, "servername", r->servername);
6390         ndr->depth++;
6391         if (r->servername) {
6392                 ndr_print_string(ndr, "servername", r->servername);
6393         }
6394         ndr->depth--;
6395         ndr_print_ptr(ndr, "printername", r->printername);
6396         ndr->depth++;
6397         if (r->printername) {
6398                 ndr_print_string(ndr, "printername", r->printername);
6399         }
6400         ndr->depth--;
6401         ndr_print_ptr(ndr, "sharename", r->sharename);
6402         ndr->depth++;
6403         if (r->sharename) {
6404                 ndr_print_string(ndr, "sharename", r->sharename);
6405         }
6406         ndr->depth--;
6407         ndr_print_ptr(ndr, "portname", r->portname);
6408         ndr->depth++;
6409         if (r->portname) {
6410                 ndr_print_string(ndr, "portname", r->portname);
6411         }
6412         ndr->depth--;
6413         ndr_print_ptr(ndr, "drivername", r->drivername);
6414         ndr->depth++;
6415         if (r->drivername) {
6416                 ndr_print_string(ndr, "drivername", r->drivername);
6417         }
6418         ndr->depth--;
6419         ndr_print_ptr(ndr, "comment", r->comment);
6420         ndr->depth++;
6421         if (r->comment) {
6422                 ndr_print_string(ndr, "comment", r->comment);
6423         }
6424         ndr->depth--;
6425         ndr_print_ptr(ndr, "location", r->location);
6426         ndr->depth++;
6427         if (r->location) {
6428                 ndr_print_string(ndr, "location", r->location);
6429         }
6430         ndr->depth--;
6431         ndr_print_ptr(ndr, "devmode", r->devmode);
6432         ndr->depth++;
6433         if (r->devmode) {
6434                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6435         }
6436         ndr->depth--;
6437         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6438         ndr->depth++;
6439         if (r->sepfile) {
6440                 ndr_print_string(ndr, "sepfile", r->sepfile);
6441         }
6442         ndr->depth--;
6443         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6444         ndr->depth++;
6445         if (r->printprocessor) {
6446                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6447         }
6448         ndr->depth--;
6449         ndr_print_ptr(ndr, "datatype", r->datatype);
6450         ndr->depth++;
6451         if (r->datatype) {
6452                 ndr_print_string(ndr, "datatype", r->datatype);
6453         }
6454         ndr->depth--;
6455         ndr_print_ptr(ndr, "parameters", r->parameters);
6456         ndr->depth++;
6457         if (r->parameters) {
6458                 ndr_print_string(ndr, "parameters", r->parameters);
6459         }
6460         ndr->depth--;
6461         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6462         ndr->depth++;
6463         if (r->secdesc) {
6464                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6465         }
6466         ndr->depth--;
6467         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6468         ndr_print_uint32(ndr, "priority", r->priority);
6469         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6470         ndr_print_uint32(ndr, "starttime", r->starttime);
6471         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6472         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6473         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6474         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6475         ndr->depth--;
6476 }
6477
6478 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6479 {
6480         if (ndr_flags & NDR_SCALARS) {
6481                 NDR_CHECK(ndr_push_align(ndr, 4));
6482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6483         }
6484         if (ndr_flags & NDR_BUFFERS) {
6485         }
6486         return NDR_ERR_SUCCESS;
6487 }
6488
6489 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6490 {
6491         if (ndr_flags & NDR_SCALARS) {
6492                 NDR_CHECK(ndr_pull_align(ndr, 4));
6493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6494         }
6495         if (ndr_flags & NDR_BUFFERS) {
6496         }
6497         return NDR_ERR_SUCCESS;
6498 }
6499
6500 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6501 {
6502         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6503         ndr->depth++;
6504         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6505         ndr->depth--;
6506 }
6507
6508 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6509 {
6510         if (ndr_flags & NDR_SCALARS) {
6511                 NDR_CHECK(ndr_push_align(ndr, 4));
6512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6514                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6515         }
6516         if (ndr_flags & NDR_BUFFERS) {
6517                 if (r->printername) {
6518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6521                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6522                 }
6523                 if (r->servername) {
6524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6528                 }
6529         }
6530         return NDR_ERR_SUCCESS;
6531 }
6532
6533 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6534 {
6535         uint32_t _ptr_printername;
6536         TALLOC_CTX *_mem_save_printername_0;
6537         uint32_t _ptr_servername;
6538         TALLOC_CTX *_mem_save_servername_0;
6539         if (ndr_flags & NDR_SCALARS) {
6540                 NDR_CHECK(ndr_pull_align(ndr, 4));
6541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6542                 if (_ptr_printername) {
6543                         NDR_PULL_ALLOC(ndr, r->printername);
6544                 } else {
6545                         r->printername = NULL;
6546                 }
6547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6548                 if (_ptr_servername) {
6549                         NDR_PULL_ALLOC(ndr, r->servername);
6550                 } else {
6551                         r->servername = NULL;
6552                 }
6553                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6554         }
6555         if (ndr_flags & NDR_BUFFERS) {
6556                 if (r->printername) {
6557                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6558                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6561                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6562                                 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));
6563                         }
6564                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6565                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6567                 }
6568                 if (r->servername) {
6569                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6570                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6573                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6574                                 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));
6575                         }
6576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6579                 }
6580         }
6581         return NDR_ERR_SUCCESS;
6582 }
6583
6584 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6585 {
6586         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6587         ndr->depth++;
6588         ndr_print_ptr(ndr, "printername", r->printername);
6589         ndr->depth++;
6590         if (r->printername) {
6591                 ndr_print_string(ndr, "printername", r->printername);
6592         }
6593         ndr->depth--;
6594         ndr_print_ptr(ndr, "servername", r->servername);
6595         ndr->depth++;
6596         if (r->servername) {
6597                 ndr_print_string(ndr, "servername", r->servername);
6598         }
6599         ndr->depth--;
6600         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6601         ndr->depth--;
6602 }
6603
6604 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6605 {
6606         if (ndr_flags & NDR_SCALARS) {
6607                 NDR_CHECK(ndr_push_align(ndr, 4));
6608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6610                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6613         }
6614         if (ndr_flags & NDR_BUFFERS) {
6615                 if (r->printername) {
6616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6620                 }
6621                 if (r->portname) {
6622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6625                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6626                 }
6627         }
6628         return NDR_ERR_SUCCESS;
6629 }
6630
6631 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6632 {
6633         uint32_t _ptr_printername;
6634         TALLOC_CTX *_mem_save_printername_0;
6635         uint32_t _ptr_portname;
6636         TALLOC_CTX *_mem_save_portname_0;
6637         if (ndr_flags & NDR_SCALARS) {
6638                 NDR_CHECK(ndr_pull_align(ndr, 4));
6639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6640                 if (_ptr_printername) {
6641                         NDR_PULL_ALLOC(ndr, r->printername);
6642                 } else {
6643                         r->printername = NULL;
6644                 }
6645                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6646                 if (_ptr_portname) {
6647                         NDR_PULL_ALLOC(ndr, r->portname);
6648                 } else {
6649                         r->portname = NULL;
6650                 }
6651                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6654         }
6655         if (ndr_flags & NDR_BUFFERS) {
6656                 if (r->printername) {
6657                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6658                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6661                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6662                                 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));
6663                         }
6664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6665                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6667                 }
6668                 if (r->portname) {
6669                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6670                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6673                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6674                                 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));
6675                         }
6676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6679                 }
6680         }
6681         return NDR_ERR_SUCCESS;
6682 }
6683
6684 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6685 {
6686         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6687         ndr->depth++;
6688         ndr_print_ptr(ndr, "printername", r->printername);
6689         ndr->depth++;
6690         if (r->printername) {
6691                 ndr_print_string(ndr, "printername", r->printername);
6692         }
6693         ndr->depth--;
6694         ndr_print_ptr(ndr, "portname", r->portname);
6695         ndr->depth++;
6696         if (r->portname) {
6697                 ndr_print_string(ndr, "portname", r->portname);
6698         }
6699         ndr->depth--;
6700         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6701         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6702         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6703         ndr->depth--;
6704 }
6705
6706 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6707 {
6708         if (ndr_flags & NDR_SCALARS) {
6709                 NDR_CHECK(ndr_push_align(ndr, 4));
6710                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6711         }
6712         if (ndr_flags & NDR_BUFFERS) {
6713         }
6714         return NDR_ERR_SUCCESS;
6715 }
6716
6717 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6718 {
6719         if (ndr_flags & NDR_SCALARS) {
6720                 NDR_CHECK(ndr_pull_align(ndr, 4));
6721                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6722         }
6723         if (ndr_flags & NDR_BUFFERS) {
6724         }
6725         return NDR_ERR_SUCCESS;
6726 }
6727
6728 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6729 {
6730         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6731         ndr->depth++;
6732         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6733         ndr->depth--;
6734 }
6735
6736 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6737 {
6738         if (ndr_flags & NDR_SCALARS) {
6739                 NDR_CHECK(ndr_push_align(ndr, 4));
6740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6741                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6742         }
6743         if (ndr_flags & NDR_BUFFERS) {
6744                 if (r->guid) {
6745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6749                 }
6750         }
6751         return NDR_ERR_SUCCESS;
6752 }
6753
6754 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6755 {
6756         uint32_t _ptr_guid;
6757         TALLOC_CTX *_mem_save_guid_0;
6758         if (ndr_flags & NDR_SCALARS) {
6759                 NDR_CHECK(ndr_pull_align(ndr, 4));
6760                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6761                 if (_ptr_guid) {
6762                         NDR_PULL_ALLOC(ndr, r->guid);
6763                 } else {
6764                         r->guid = NULL;
6765                 }
6766                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6767         }
6768         if (ndr_flags & NDR_BUFFERS) {
6769                 if (r->guid) {
6770                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6771                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6774                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6775                                 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));
6776                         }
6777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6780                 }
6781         }
6782         return NDR_ERR_SUCCESS;
6783 }
6784
6785 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6786 {
6787         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6788         ndr->depth++;
6789         ndr_print_ptr(ndr, "guid", r->guid);
6790         ndr->depth++;
6791         if (r->guid) {
6792                 ndr_print_string(ndr, "guid", r->guid);
6793         }
6794         ndr->depth--;
6795         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6796         ndr->depth--;
6797 }
6798
6799 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6800 {
6801         if (ndr_flags & NDR_SCALARS) {
6802                 int level = ndr_push_get_switch_value(ndr, r);
6803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6804                 switch (level) {
6805                         case 0: {
6806                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6807                         break; }
6808
6809                         case 1: {
6810                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6811                         break; }
6812
6813                         case 2: {
6814                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6815                         break; }
6816
6817                         case 3: {
6818                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6819                         break; }
6820
6821                         case 4: {
6822                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6823                         break; }
6824
6825                         case 5: {
6826                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6827                         break; }
6828
6829                         case 6: {
6830                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6831                         break; }
6832
6833                         case 7: {
6834                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6835                         break; }
6836
6837                         case 8: {
6838                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6839                         break; }
6840
6841                         case 9: {
6842                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6843                         break; }
6844
6845                         default: {
6846                         break; }
6847
6848                 }
6849         }
6850         if (ndr_flags & NDR_BUFFERS) {
6851                 int level = ndr_push_get_switch_value(ndr, r);
6852                 switch (level) {
6853                         case 0:
6854                                 if (r->info0) {
6855                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6856                                 }
6857                         break;
6858
6859                         case 1:
6860                                 if (r->info1) {
6861                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6862                                 }
6863                         break;
6864
6865                         case 2:
6866                                 if (r->info2) {
6867                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6868                                 }
6869                         break;
6870
6871                         case 3:
6872                                 if (r->info3) {
6873                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6874                                 }
6875                         break;
6876
6877                         case 4:
6878                                 if (r->info4) {
6879                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6880                                 }
6881                         break;
6882
6883                         case 5:
6884                                 if (r->info5) {
6885                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6886                                 }
6887                         break;
6888
6889                         case 6:
6890                                 if (r->info6) {
6891                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6892                                 }
6893                         break;
6894
6895                         case 7:
6896                                 if (r->info7) {
6897                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6898                                 }
6899                         break;
6900
6901                         case 8:
6902                                 if (r->info8) {
6903                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6904                                 }
6905                         break;
6906
6907                         case 9:
6908                                 if (r->info9) {
6909                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
6910                                 }
6911                         break;
6912
6913                         default:
6914                         break;
6915
6916                 }
6917         }
6918         return NDR_ERR_SUCCESS;
6919 }
6920
6921 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
6922 {
6923         int level;
6924         uint32_t _level;
6925         TALLOC_CTX *_mem_save_info0_0;
6926         TALLOC_CTX *_mem_save_info1_0;
6927         TALLOC_CTX *_mem_save_info2_0;
6928         TALLOC_CTX *_mem_save_info3_0;
6929         TALLOC_CTX *_mem_save_info4_0;
6930         TALLOC_CTX *_mem_save_info5_0;
6931         TALLOC_CTX *_mem_save_info6_0;
6932         TALLOC_CTX *_mem_save_info7_0;
6933         TALLOC_CTX *_mem_save_info8_0;
6934         TALLOC_CTX *_mem_save_info9_0;
6935         level = ndr_pull_get_switch_value(ndr, r);
6936         if (ndr_flags & NDR_SCALARS) {
6937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6938                 if (_level != level) {
6939                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6940                 }
6941                 switch (level) {
6942                         case 0: {
6943                                 uint32_t _ptr_info0;
6944                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
6945                                 if (_ptr_info0) {
6946                                         NDR_PULL_ALLOC(ndr, r->info0);
6947                                 } else {
6948                                         r->info0 = NULL;
6949                                 }
6950                         break; }
6951
6952                         case 1: {
6953                                 uint32_t _ptr_info1;
6954                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6955                                 if (_ptr_info1) {
6956                                         NDR_PULL_ALLOC(ndr, r->info1);
6957                                 } else {
6958                                         r->info1 = NULL;
6959                                 }
6960                         break; }
6961
6962                         case 2: {
6963                                 uint32_t _ptr_info2;
6964                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6965                                 if (_ptr_info2) {
6966                                         NDR_PULL_ALLOC(ndr, r->info2);
6967                                 } else {
6968                                         r->info2 = NULL;
6969                                 }
6970                         break; }
6971
6972                         case 3: {
6973                                 uint32_t _ptr_info3;
6974                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6975                                 if (_ptr_info3) {
6976                                         NDR_PULL_ALLOC(ndr, r->info3);
6977                                 } else {
6978                                         r->info3 = NULL;
6979                                 }
6980                         break; }
6981
6982                         case 4: {
6983                                 uint32_t _ptr_info4;
6984                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6985                                 if (_ptr_info4) {
6986                                         NDR_PULL_ALLOC(ndr, r->info4);
6987                                 } else {
6988                                         r->info4 = NULL;
6989                                 }
6990                         break; }
6991
6992                         case 5: {
6993                                 uint32_t _ptr_info5;
6994                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
6995                                 if (_ptr_info5) {
6996                                         NDR_PULL_ALLOC(ndr, r->info5);
6997                                 } else {
6998                                         r->info5 = NULL;
6999                                 }
7000                         break; }
7001
7002                         case 6: {
7003                                 uint32_t _ptr_info6;
7004                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7005                                 if (_ptr_info6) {
7006                                         NDR_PULL_ALLOC(ndr, r->info6);
7007                                 } else {
7008                                         r->info6 = NULL;
7009                                 }
7010                         break; }
7011
7012                         case 7: {
7013                                 uint32_t _ptr_info7;
7014                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7015                                 if (_ptr_info7) {
7016                                         NDR_PULL_ALLOC(ndr, r->info7);
7017                                 } else {
7018                                         r->info7 = NULL;
7019                                 }
7020                         break; }
7021
7022                         case 8: {
7023                                 uint32_t _ptr_info8;
7024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7025                                 if (_ptr_info8) {
7026                                         NDR_PULL_ALLOC(ndr, r->info8);
7027                                 } else {
7028                                         r->info8 = NULL;
7029                                 }
7030                         break; }
7031
7032                         case 9: {
7033                                 uint32_t _ptr_info9;
7034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7035                                 if (_ptr_info9) {
7036                                         NDR_PULL_ALLOC(ndr, r->info9);
7037                                 } else {
7038                                         r->info9 = NULL;
7039                                 }
7040                         break; }
7041
7042                         default: {
7043                         break; }
7044
7045                 }
7046         }
7047         if (ndr_flags & NDR_BUFFERS) {
7048                 switch (level) {
7049                         case 0:
7050                                 if (r->info0) {
7051                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7052                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7053                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7054                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7055                                 }
7056                         break;
7057
7058                         case 1:
7059                                 if (r->info1) {
7060                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7061                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7062                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7063                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7064                                 }
7065                         break;
7066
7067                         case 2:
7068                                 if (r->info2) {
7069                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7070                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7071                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7072                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7073                                 }
7074                         break;
7075
7076                         case 3:
7077                                 if (r->info3) {
7078                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7079                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7080                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7081                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7082                                 }
7083                         break;
7084
7085                         case 4:
7086                                 if (r->info4) {
7087                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7088                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7089                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7090                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7091                                 }
7092                         break;
7093
7094                         case 5:
7095                                 if (r->info5) {
7096                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7097                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7098                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7099                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7100                                 }
7101                         break;
7102
7103                         case 6:
7104                                 if (r->info6) {
7105                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7107                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7108                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7109                                 }
7110                         break;
7111
7112                         case 7:
7113                                 if (r->info7) {
7114                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7115                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7116                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7117                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7118                                 }
7119                         break;
7120
7121                         case 8:
7122                                 if (r->info8) {
7123                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7124                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7125                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7126                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7127                                 }
7128                         break;
7129
7130                         case 9:
7131                                 if (r->info9) {
7132                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7133                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7134                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7135                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7136                                 }
7137                         break;
7138
7139                         default:
7140                         break;
7141
7142                 }
7143         }
7144         return NDR_ERR_SUCCESS;
7145 }
7146
7147 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7148 {
7149         int level;
7150         level = ndr_print_get_switch_value(ndr, r);
7151         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7152         switch (level) {
7153                 case 0:
7154                         ndr_print_ptr(ndr, "info0", r->info0);
7155                         ndr->depth++;
7156                         if (r->info0) {
7157                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7158                         }
7159                         ndr->depth--;
7160                 break;
7161
7162                 case 1:
7163                         ndr_print_ptr(ndr, "info1", r->info1);
7164                         ndr->depth++;
7165                         if (r->info1) {
7166                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7167                         }
7168                         ndr->depth--;
7169                 break;
7170
7171                 case 2:
7172                         ndr_print_ptr(ndr, "info2", r->info2);
7173                         ndr->depth++;
7174                         if (r->info2) {
7175                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7176                         }
7177                         ndr->depth--;
7178                 break;
7179
7180                 case 3:
7181                         ndr_print_ptr(ndr, "info3", r->info3);
7182                         ndr->depth++;
7183                         if (r->info3) {
7184                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7185                         }
7186                         ndr->depth--;
7187                 break;
7188
7189                 case 4:
7190                         ndr_print_ptr(ndr, "info4", r->info4);
7191                         ndr->depth++;
7192                         if (r->info4) {
7193                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7194                         }
7195                         ndr->depth--;
7196                 break;
7197
7198                 case 5:
7199                         ndr_print_ptr(ndr, "info5", r->info5);
7200                         ndr->depth++;
7201                         if (r->info5) {
7202                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7203                         }
7204                         ndr->depth--;
7205                 break;
7206
7207                 case 6:
7208                         ndr_print_ptr(ndr, "info6", r->info6);
7209                         ndr->depth++;
7210                         if (r->info6) {
7211                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7212                         }
7213                         ndr->depth--;
7214                 break;
7215
7216                 case 7:
7217                         ndr_print_ptr(ndr, "info7", r->info7);
7218                         ndr->depth++;
7219                         if (r->info7) {
7220                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7221                         }
7222                         ndr->depth--;
7223                 break;
7224
7225                 case 8:
7226                         ndr_print_ptr(ndr, "info8", r->info8);
7227                         ndr->depth++;
7228                         if (r->info8) {
7229                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7230                         }
7231                         ndr->depth--;
7232                 break;
7233
7234                 case 9:
7235                         ndr_print_ptr(ndr, "info9", r->info9);
7236                         ndr->depth++;
7237                         if (r->info9) {
7238                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7239                         }
7240                         ndr->depth--;
7241                 break;
7242
7243                 default:
7244                 break;
7245
7246         }
7247 }
7248
7249 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7250 {
7251         if (ndr_flags & NDR_SCALARS) {
7252                 NDR_CHECK(ndr_push_align(ndr, 4));
7253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7254                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7255                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7256         }
7257         if (ndr_flags & NDR_BUFFERS) {
7258                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7259         }
7260         return NDR_ERR_SUCCESS;
7261 }
7262
7263 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7264 {
7265         if (ndr_flags & NDR_SCALARS) {
7266                 NDR_CHECK(ndr_pull_align(ndr, 4));
7267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7268                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7269                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7270         }
7271         if (ndr_flags & NDR_BUFFERS) {
7272                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7273         }
7274         return NDR_ERR_SUCCESS;
7275 }
7276
7277 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7278 {
7279         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7280         ndr->depth++;
7281         ndr_print_uint32(ndr, "level", r->level);
7282         ndr_print_set_switch_value(ndr, &r->info, r->level);
7283         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7284         ndr->depth--;
7285 }
7286
7287 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7288 {
7289         if (ndr_flags & NDR_SCALARS) {
7290                 NDR_CHECK(ndr_push_align(ndr, 4));
7291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7292                 {
7293                         uint32_t _flags_save_string_array = ndr->flags;
7294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7295                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7296                         ndr->flags = _flags_save_string_array;
7297                 }
7298         }
7299         if (ndr_flags & NDR_BUFFERS) {
7300         }
7301         return NDR_ERR_SUCCESS;
7302 }
7303
7304 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7305 {
7306         if (ndr_flags & NDR_SCALARS) {
7307                 NDR_CHECK(ndr_pull_align(ndr, 4));
7308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7309                 {
7310                         uint32_t _flags_save_string_array = ndr->flags;
7311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7312                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7313                         ndr->flags = _flags_save_string_array;
7314                 }
7315         }
7316         if (ndr_flags & NDR_BUFFERS) {
7317         }
7318         return NDR_ERR_SUCCESS;
7319 }
7320
7321 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7322 {
7323         ndr_print_struct(ndr, name, "spoolss_StringArray");
7324         ndr->depth++;
7325         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);
7326         ndr_print_string_array(ndr, "string", r->string);
7327         ndr->depth--;
7328 }
7329
7330 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7331 {
7332         if (ndr_flags & NDR_SCALARS) {
7333                 NDR_CHECK(ndr_push_align(ndr, 4));
7334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7335         }
7336         if (ndr_flags & NDR_BUFFERS) {
7337                 if (r->driver_name) {
7338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7342                 }
7343         }
7344         return NDR_ERR_SUCCESS;
7345 }
7346
7347 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7348 {
7349         uint32_t _ptr_driver_name;
7350         TALLOC_CTX *_mem_save_driver_name_0;
7351         if (ndr_flags & NDR_SCALARS) {
7352                 NDR_CHECK(ndr_pull_align(ndr, 4));
7353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7354                 if (_ptr_driver_name) {
7355                         NDR_PULL_ALLOC(ndr, r->driver_name);
7356                 } else {
7357                         r->driver_name = NULL;
7358                 }
7359         }
7360         if (ndr_flags & NDR_BUFFERS) {
7361                 if (r->driver_name) {
7362                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7363                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7366                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7367                                 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));
7368                         }
7369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7372                 }
7373         }
7374         return NDR_ERR_SUCCESS;
7375 }
7376
7377 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7378 {
7379         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7380         ndr->depth++;
7381         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7382         ndr->depth++;
7383         if (r->driver_name) {
7384                 ndr_print_string(ndr, "driver_name", r->driver_name);
7385         }
7386         ndr->depth--;
7387         ndr->depth--;
7388 }
7389
7390 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7391 {
7392         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7393         return NDR_ERR_SUCCESS;
7394 }
7395
7396 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7397 {
7398         uint32_t v;
7399         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7400         *r = v;
7401         return NDR_ERR_SUCCESS;
7402 }
7403
7404 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7405 {
7406         const char *val = NULL;
7407
7408         switch (r) {
7409                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7410                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7411                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7412                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7413         }
7414         ndr_print_enum(ndr, name, "ENUM", val, r);
7415 }
7416
7417 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7418 {
7419         if (ndr_flags & NDR_SCALARS) {
7420                 NDR_CHECK(ndr_push_align(ndr, 4));
7421                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7427         }
7428         if (ndr_flags & NDR_BUFFERS) {
7429                 if (r->driver_name) {
7430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7434                 }
7435                 if (r->architecture) {
7436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7440                 }
7441                 if (r->driver_path) {
7442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7446                 }
7447                 if (r->data_file) {
7448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7452                 }
7453                 if (r->config_file) {
7454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7457                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7458                 }
7459         }
7460         return NDR_ERR_SUCCESS;
7461 }
7462
7463 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7464 {
7465         uint32_t _ptr_driver_name;
7466         TALLOC_CTX *_mem_save_driver_name_0;
7467         uint32_t _ptr_architecture;
7468         TALLOC_CTX *_mem_save_architecture_0;
7469         uint32_t _ptr_driver_path;
7470         TALLOC_CTX *_mem_save_driver_path_0;
7471         uint32_t _ptr_data_file;
7472         TALLOC_CTX *_mem_save_data_file_0;
7473         uint32_t _ptr_config_file;
7474         TALLOC_CTX *_mem_save_config_file_0;
7475         if (ndr_flags & NDR_SCALARS) {
7476                 NDR_CHECK(ndr_pull_align(ndr, 4));
7477                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7479                 if (_ptr_driver_name) {
7480                         NDR_PULL_ALLOC(ndr, r->driver_name);
7481                 } else {
7482                         r->driver_name = NULL;
7483                 }
7484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7485                 if (_ptr_architecture) {
7486                         NDR_PULL_ALLOC(ndr, r->architecture);
7487                 } else {
7488                         r->architecture = NULL;
7489                 }
7490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7491                 if (_ptr_driver_path) {
7492                         NDR_PULL_ALLOC(ndr, r->driver_path);
7493                 } else {
7494                         r->driver_path = NULL;
7495                 }
7496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7497                 if (_ptr_data_file) {
7498                         NDR_PULL_ALLOC(ndr, r->data_file);
7499                 } else {
7500                         r->data_file = NULL;
7501                 }
7502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7503                 if (_ptr_config_file) {
7504                         NDR_PULL_ALLOC(ndr, r->config_file);
7505                 } else {
7506                         r->config_file = NULL;
7507                 }
7508         }
7509         if (ndr_flags & NDR_BUFFERS) {
7510                 if (r->driver_name) {
7511                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7512                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7515                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7516                                 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));
7517                         }
7518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7521                 }
7522                 if (r->architecture) {
7523                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7524                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7527                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7528                                 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));
7529                         }
7530                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7531                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7533                 }
7534                 if (r->driver_path) {
7535                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7536                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7539                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7540                                 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));
7541                         }
7542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7545                 }
7546                 if (r->data_file) {
7547                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7548                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7551                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7552                                 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));
7553                         }
7554                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7555                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7557                 }
7558                 if (r->config_file) {
7559                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7560                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7561                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7562                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7563                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7564                                 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));
7565                         }
7566                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7567                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7569                 }
7570         }
7571         return NDR_ERR_SUCCESS;
7572 }
7573
7574 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7575 {
7576         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7577         ndr->depth++;
7578         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7579         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7580         ndr->depth++;
7581         if (r->driver_name) {
7582                 ndr_print_string(ndr, "driver_name", r->driver_name);
7583         }
7584         ndr->depth--;
7585         ndr_print_ptr(ndr, "architecture", r->architecture);
7586         ndr->depth++;
7587         if (r->architecture) {
7588                 ndr_print_string(ndr, "architecture", r->architecture);
7589         }
7590         ndr->depth--;
7591         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7592         ndr->depth++;
7593         if (r->driver_path) {
7594                 ndr_print_string(ndr, "driver_path", r->driver_path);
7595         }
7596         ndr->depth--;
7597         ndr_print_ptr(ndr, "data_file", r->data_file);
7598         ndr->depth++;
7599         if (r->data_file) {
7600                 ndr_print_string(ndr, "data_file", r->data_file);
7601         }
7602         ndr->depth--;
7603         ndr_print_ptr(ndr, "config_file", r->config_file);
7604         ndr->depth++;
7605         if (r->config_file) {
7606                 ndr_print_string(ndr, "config_file", r->config_file);
7607         }
7608         ndr->depth--;
7609         ndr->depth--;
7610 }
7611
7612 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7613 {
7614         if (ndr_flags & NDR_SCALARS) {
7615                 NDR_CHECK(ndr_push_align(ndr, 4));
7616                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7627         }
7628         if (ndr_flags & NDR_BUFFERS) {
7629                 if (r->driver_name) {
7630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7633                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7634                 }
7635                 if (r->architecture) {
7636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7639                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7640                 }
7641                 if (r->driver_path) {
7642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7645                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7646                 }
7647                 if (r->data_file) {
7648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7651                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7652                 }
7653                 if (r->config_file) {
7654                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7658                 }
7659                 if (r->help_file) {
7660                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7664                 }
7665                 if (r->monitor_name) {
7666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7670                 }
7671                 if (r->default_datatype) {
7672                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7675                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7676                 }
7677                 if (r->dependent_files) {
7678                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7679                 }
7680         }
7681         return NDR_ERR_SUCCESS;
7682 }
7683
7684 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7685 {
7686         uint32_t _ptr_driver_name;
7687         TALLOC_CTX *_mem_save_driver_name_0;
7688         uint32_t _ptr_architecture;
7689         TALLOC_CTX *_mem_save_architecture_0;
7690         uint32_t _ptr_driver_path;
7691         TALLOC_CTX *_mem_save_driver_path_0;
7692         uint32_t _ptr_data_file;
7693         TALLOC_CTX *_mem_save_data_file_0;
7694         uint32_t _ptr_config_file;
7695         TALLOC_CTX *_mem_save_config_file_0;
7696         uint32_t _ptr_help_file;
7697         TALLOC_CTX *_mem_save_help_file_0;
7698         uint32_t _ptr_monitor_name;
7699         TALLOC_CTX *_mem_save_monitor_name_0;
7700         uint32_t _ptr_default_datatype;
7701         TALLOC_CTX *_mem_save_default_datatype_0;
7702         uint32_t _ptr_dependent_files;
7703         TALLOC_CTX *_mem_save_dependent_files_0;
7704         if (ndr_flags & NDR_SCALARS) {
7705                 NDR_CHECK(ndr_pull_align(ndr, 4));
7706                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7708                 if (_ptr_driver_name) {
7709                         NDR_PULL_ALLOC(ndr, r->driver_name);
7710                 } else {
7711                         r->driver_name = NULL;
7712                 }
7713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7714                 if (_ptr_architecture) {
7715                         NDR_PULL_ALLOC(ndr, r->architecture);
7716                 } else {
7717                         r->architecture = NULL;
7718                 }
7719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7720                 if (_ptr_driver_path) {
7721                         NDR_PULL_ALLOC(ndr, r->driver_path);
7722                 } else {
7723                         r->driver_path = NULL;
7724                 }
7725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7726                 if (_ptr_data_file) {
7727                         NDR_PULL_ALLOC(ndr, r->data_file);
7728                 } else {
7729                         r->data_file = NULL;
7730                 }
7731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7732                 if (_ptr_config_file) {
7733                         NDR_PULL_ALLOC(ndr, r->config_file);
7734                 } else {
7735                         r->config_file = NULL;
7736                 }
7737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7738                 if (_ptr_help_file) {
7739                         NDR_PULL_ALLOC(ndr, r->help_file);
7740                 } else {
7741                         r->help_file = NULL;
7742                 }
7743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7744                 if (_ptr_monitor_name) {
7745                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7746                 } else {
7747                         r->monitor_name = NULL;
7748                 }
7749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7750                 if (_ptr_default_datatype) {
7751                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7752                 } else {
7753                         r->default_datatype = NULL;
7754                 }
7755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7757                 if (_ptr_dependent_files) {
7758                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7759                 } else {
7760                         r->dependent_files = NULL;
7761                 }
7762         }
7763         if (ndr_flags & NDR_BUFFERS) {
7764                 if (r->driver_name) {
7765                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7766                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7769                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7770                                 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));
7771                         }
7772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7775                 }
7776                 if (r->architecture) {
7777                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7778                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7780                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7781                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7782                                 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));
7783                         }
7784                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7785                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7787                 }
7788                 if (r->driver_path) {
7789                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7790                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7793                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7794                                 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));
7795                         }
7796                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7797                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7799                 }
7800                 if (r->data_file) {
7801                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7802                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7805                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7806                                 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));
7807                         }
7808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7811                 }
7812                 if (r->config_file) {
7813                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7814                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7817                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7818                                 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));
7819                         }
7820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7823                 }
7824                 if (r->help_file) {
7825                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7826                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7827                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7828                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7829                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7830                                 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));
7831                         }
7832                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7835                 }
7836                 if (r->monitor_name) {
7837                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7838                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7839                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7840                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7841                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7842                                 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));
7843                         }
7844                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7845                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7847                 }
7848                 if (r->default_datatype) {
7849                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7850                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7852                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7853                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7854                                 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));
7855                         }
7856                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7857                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7858                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7859                 }
7860                 if (r->dependent_files) {
7861                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7862                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7863                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7865                 }
7866         }
7867         return NDR_ERR_SUCCESS;
7868 }
7869
7870 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7871 {
7872         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7873         ndr->depth++;
7874         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7875         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7876         ndr->depth++;
7877         if (r->driver_name) {
7878                 ndr_print_string(ndr, "driver_name", r->driver_name);
7879         }
7880         ndr->depth--;
7881         ndr_print_ptr(ndr, "architecture", r->architecture);
7882         ndr->depth++;
7883         if (r->architecture) {
7884                 ndr_print_string(ndr, "architecture", r->architecture);
7885         }
7886         ndr->depth--;
7887         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7888         ndr->depth++;
7889         if (r->driver_path) {
7890                 ndr_print_string(ndr, "driver_path", r->driver_path);
7891         }
7892         ndr->depth--;
7893         ndr_print_ptr(ndr, "data_file", r->data_file);
7894         ndr->depth++;
7895         if (r->data_file) {
7896                 ndr_print_string(ndr, "data_file", r->data_file);
7897         }
7898         ndr->depth--;
7899         ndr_print_ptr(ndr, "config_file", r->config_file);
7900         ndr->depth++;
7901         if (r->config_file) {
7902                 ndr_print_string(ndr, "config_file", r->config_file);
7903         }
7904         ndr->depth--;
7905         ndr_print_ptr(ndr, "help_file", r->help_file);
7906         ndr->depth++;
7907         if (r->help_file) {
7908                 ndr_print_string(ndr, "help_file", r->help_file);
7909         }
7910         ndr->depth--;
7911         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7912         ndr->depth++;
7913         if (r->monitor_name) {
7914                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7915         }
7916         ndr->depth--;
7917         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7918         ndr->depth++;
7919         if (r->default_datatype) {
7920                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7921         }
7922         ndr->depth--;
7923         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);
7924         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7925         ndr->depth++;
7926         if (r->dependent_files) {
7927                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7928         }
7929         ndr->depth--;
7930         ndr->depth--;
7931 }
7932
7933 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
7934 {
7935         if (ndr_flags & NDR_SCALARS) {
7936                 NDR_CHECK(ndr_push_align(ndr, 4));
7937                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7947                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
7950         }
7951         if (ndr_flags & NDR_BUFFERS) {
7952                 if (r->driver_name) {
7953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7957                 }
7958                 if (r->architecture) {
7959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7962                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7963                 }
7964                 if (r->driver_path) {
7965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7969                 }
7970                 if (r->data_file) {
7971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7974                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7975                 }
7976                 if (r->config_file) {
7977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7980                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7981                 }
7982                 if (r->help_file) {
7983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7986                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7987                 }
7988                 if (r->monitor_name) {
7989                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7992                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7993                 }
7994                 if (r->default_datatype) {
7995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7999                 }
8000                 if (r->dependent_files) {
8001                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8002                 }
8003                 if (r->previous_names) {
8004                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8005                 }
8006         }
8007         return NDR_ERR_SUCCESS;
8008 }
8009
8010 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8011 {
8012         uint32_t _ptr_driver_name;
8013         TALLOC_CTX *_mem_save_driver_name_0;
8014         uint32_t _ptr_architecture;
8015         TALLOC_CTX *_mem_save_architecture_0;
8016         uint32_t _ptr_driver_path;
8017         TALLOC_CTX *_mem_save_driver_path_0;
8018         uint32_t _ptr_data_file;
8019         TALLOC_CTX *_mem_save_data_file_0;
8020         uint32_t _ptr_config_file;
8021         TALLOC_CTX *_mem_save_config_file_0;
8022         uint32_t _ptr_help_file;
8023         TALLOC_CTX *_mem_save_help_file_0;
8024         uint32_t _ptr_monitor_name;
8025         TALLOC_CTX *_mem_save_monitor_name_0;
8026         uint32_t _ptr_default_datatype;
8027         TALLOC_CTX *_mem_save_default_datatype_0;
8028         uint32_t _ptr_dependent_files;
8029         TALLOC_CTX *_mem_save_dependent_files_0;
8030         uint32_t _ptr_previous_names;
8031         TALLOC_CTX *_mem_save_previous_names_0;
8032         if (ndr_flags & NDR_SCALARS) {
8033                 NDR_CHECK(ndr_pull_align(ndr, 4));
8034                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8036                 if (_ptr_driver_name) {
8037                         NDR_PULL_ALLOC(ndr, r->driver_name);
8038                 } else {
8039                         r->driver_name = NULL;
8040                 }
8041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8042                 if (_ptr_architecture) {
8043                         NDR_PULL_ALLOC(ndr, r->architecture);
8044                 } else {
8045                         r->architecture = NULL;
8046                 }
8047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8048                 if (_ptr_driver_path) {
8049                         NDR_PULL_ALLOC(ndr, r->driver_path);
8050                 } else {
8051                         r->driver_path = NULL;
8052                 }
8053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8054                 if (_ptr_data_file) {
8055                         NDR_PULL_ALLOC(ndr, r->data_file);
8056                 } else {
8057                         r->data_file = NULL;
8058                 }
8059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8060                 if (_ptr_config_file) {
8061                         NDR_PULL_ALLOC(ndr, r->config_file);
8062                 } else {
8063                         r->config_file = NULL;
8064                 }
8065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8066                 if (_ptr_help_file) {
8067                         NDR_PULL_ALLOC(ndr, r->help_file);
8068                 } else {
8069                         r->help_file = NULL;
8070                 }
8071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8072                 if (_ptr_monitor_name) {
8073                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8074                 } else {
8075                         r->monitor_name = NULL;
8076                 }
8077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8078                 if (_ptr_default_datatype) {
8079                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8080                 } else {
8081                         r->default_datatype = NULL;
8082                 }
8083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8085                 if (_ptr_dependent_files) {
8086                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8087                 } else {
8088                         r->dependent_files = NULL;
8089                 }
8090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8092                 if (_ptr_previous_names) {
8093                         NDR_PULL_ALLOC(ndr, r->previous_names);
8094                 } else {
8095                         r->previous_names = NULL;
8096                 }
8097         }
8098         if (ndr_flags & NDR_BUFFERS) {
8099                 if (r->driver_name) {
8100                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8101                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8104                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8105                                 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));
8106                         }
8107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8110                 }
8111                 if (r->architecture) {
8112                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8113                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8116                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8117                                 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));
8118                         }
8119                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8120                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8122                 }
8123                 if (r->driver_path) {
8124                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8125                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8126                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8127                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8128                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8129                                 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));
8130                         }
8131                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8132                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8134                 }
8135                 if (r->data_file) {
8136                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8137                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8139                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8140                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8141                                 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));
8142                         }
8143                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8144                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8146                 }
8147                 if (r->config_file) {
8148                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8149                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8150                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8151                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8152                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8153                                 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));
8154                         }
8155                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8156                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8158                 }
8159                 if (r->help_file) {
8160                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8161                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8164                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8165                                 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));
8166                         }
8167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8168                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8170                 }
8171                 if (r->monitor_name) {
8172                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8173                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8176                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8177                                 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));
8178                         }
8179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8182                 }
8183                 if (r->default_datatype) {
8184                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8185                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8186                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8187                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8188                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8189                                 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));
8190                         }
8191                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8192                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8194                 }
8195                 if (r->dependent_files) {
8196                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8197                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8198                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8200                 }
8201                 if (r->previous_names) {
8202                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8203                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8204                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8205                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8206                 }
8207         }
8208         return NDR_ERR_SUCCESS;
8209 }
8210
8211 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8212 {
8213         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8214         ndr->depth++;
8215         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8216         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8217         ndr->depth++;
8218         if (r->driver_name) {
8219                 ndr_print_string(ndr, "driver_name", r->driver_name);
8220         }
8221         ndr->depth--;
8222         ndr_print_ptr(ndr, "architecture", r->architecture);
8223         ndr->depth++;
8224         if (r->architecture) {
8225                 ndr_print_string(ndr, "architecture", r->architecture);
8226         }
8227         ndr->depth--;
8228         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8229         ndr->depth++;
8230         if (r->driver_path) {
8231                 ndr_print_string(ndr, "driver_path", r->driver_path);
8232         }
8233         ndr->depth--;
8234         ndr_print_ptr(ndr, "data_file", r->data_file);
8235         ndr->depth++;
8236         if (r->data_file) {
8237                 ndr_print_string(ndr, "data_file", r->data_file);
8238         }
8239         ndr->depth--;
8240         ndr_print_ptr(ndr, "config_file", r->config_file);
8241         ndr->depth++;
8242         if (r->config_file) {
8243                 ndr_print_string(ndr, "config_file", r->config_file);
8244         }
8245         ndr->depth--;
8246         ndr_print_ptr(ndr, "help_file", r->help_file);
8247         ndr->depth++;
8248         if (r->help_file) {
8249                 ndr_print_string(ndr, "help_file", r->help_file);
8250         }
8251         ndr->depth--;
8252         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8253         ndr->depth++;
8254         if (r->monitor_name) {
8255                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8256         }
8257         ndr->depth--;
8258         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8259         ndr->depth++;
8260         if (r->default_datatype) {
8261                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8262         }
8263         ndr->depth--;
8264         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);
8265         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8266         ndr->depth++;
8267         if (r->dependent_files) {
8268                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8269         }
8270         ndr->depth--;
8271         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);
8272         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8273         ndr->depth++;
8274         if (r->previous_names) {
8275                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8276         }
8277         ndr->depth--;
8278         ndr->depth--;
8279 }
8280
8281 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8282 {
8283         if (ndr_flags & NDR_SCALARS) {
8284                 NDR_CHECK(ndr_push_align(ndr, 8));
8285                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8293                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8298                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8299                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8300                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8301                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8303                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8304         }
8305         if (ndr_flags & NDR_BUFFERS) {
8306                 if (r->driver_name) {
8307                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8308                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8309                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8310                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8311                 }
8312                 if (r->architecture) {
8313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8315                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8316                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8317                 }
8318                 if (r->driver_path) {
8319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8320                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8321                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8322                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8323                 }
8324                 if (r->data_file) {
8325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8329                 }
8330                 if (r->config_file) {
8331                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8334                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8335                 }
8336                 if (r->help_file) {
8337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8341                 }
8342                 if (r->monitor_name) {
8343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8346                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8347                 }
8348                 if (r->default_datatype) {
8349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8353                 }
8354                 if (r->dependent_files) {
8355                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8356                 }
8357                 if (r->previous_names) {
8358                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8359                 }
8360                 if (r->manufacturer_name) {
8361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8364                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8365                 }
8366                 if (r->manufacturer_url) {
8367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8371                 }
8372                 if (r->hardware_id) {
8373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8377                 }
8378                 if (r->provider) {
8379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8383                 }
8384         }
8385         return NDR_ERR_SUCCESS;
8386 }
8387
8388 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8389 {
8390         uint32_t _ptr_driver_name;
8391         TALLOC_CTX *_mem_save_driver_name_0;
8392         uint32_t _ptr_architecture;
8393         TALLOC_CTX *_mem_save_architecture_0;
8394         uint32_t _ptr_driver_path;
8395         TALLOC_CTX *_mem_save_driver_path_0;
8396         uint32_t _ptr_data_file;
8397         TALLOC_CTX *_mem_save_data_file_0;
8398         uint32_t _ptr_config_file;
8399         TALLOC_CTX *_mem_save_config_file_0;
8400         uint32_t _ptr_help_file;
8401         TALLOC_CTX *_mem_save_help_file_0;
8402         uint32_t _ptr_monitor_name;
8403         TALLOC_CTX *_mem_save_monitor_name_0;
8404         uint32_t _ptr_default_datatype;
8405         TALLOC_CTX *_mem_save_default_datatype_0;
8406         uint32_t _ptr_dependent_files;
8407         TALLOC_CTX *_mem_save_dependent_files_0;
8408         uint32_t _ptr_previous_names;
8409         TALLOC_CTX *_mem_save_previous_names_0;
8410         uint32_t _ptr_manufacturer_name;
8411         TALLOC_CTX *_mem_save_manufacturer_name_0;
8412         uint32_t _ptr_manufacturer_url;
8413         TALLOC_CTX *_mem_save_manufacturer_url_0;
8414         uint32_t _ptr_hardware_id;
8415         TALLOC_CTX *_mem_save_hardware_id_0;
8416         uint32_t _ptr_provider;
8417         TALLOC_CTX *_mem_save_provider_0;
8418         if (ndr_flags & NDR_SCALARS) {
8419                 NDR_CHECK(ndr_pull_align(ndr, 8));
8420                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8422                 if (_ptr_driver_name) {
8423                         NDR_PULL_ALLOC(ndr, r->driver_name);
8424                 } else {
8425                         r->driver_name = NULL;
8426                 }
8427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8428                 if (_ptr_architecture) {
8429                         NDR_PULL_ALLOC(ndr, r->architecture);
8430                 } else {
8431                         r->architecture = NULL;
8432                 }
8433                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8434                 if (_ptr_driver_path) {
8435                         NDR_PULL_ALLOC(ndr, r->driver_path);
8436                 } else {
8437                         r->driver_path = NULL;
8438                 }
8439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8440                 if (_ptr_data_file) {
8441                         NDR_PULL_ALLOC(ndr, r->data_file);
8442                 } else {
8443                         r->data_file = NULL;
8444                 }
8445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8446                 if (_ptr_config_file) {
8447                         NDR_PULL_ALLOC(ndr, r->config_file);
8448                 } else {
8449                         r->config_file = NULL;
8450                 }
8451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8452                 if (_ptr_help_file) {
8453                         NDR_PULL_ALLOC(ndr, r->help_file);
8454                 } else {
8455                         r->help_file = NULL;
8456                 }
8457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8458                 if (_ptr_monitor_name) {
8459                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8460                 } else {
8461                         r->monitor_name = NULL;
8462                 }
8463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8464                 if (_ptr_default_datatype) {
8465                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8466                 } else {
8467                         r->default_datatype = NULL;
8468                 }
8469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8471                 if (_ptr_dependent_files) {
8472                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8473                 } else {
8474                         r->dependent_files = NULL;
8475                 }
8476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8478                 if (_ptr_previous_names) {
8479                         NDR_PULL_ALLOC(ndr, r->previous_names);
8480                 } else {
8481                         r->previous_names = NULL;
8482                 }
8483                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8484                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8486                 if (_ptr_manufacturer_name) {
8487                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8488                 } else {
8489                         r->manufacturer_name = NULL;
8490                 }
8491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8492                 if (_ptr_manufacturer_url) {
8493                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8494                 } else {
8495                         r->manufacturer_url = NULL;
8496                 }
8497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8498                 if (_ptr_hardware_id) {
8499                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8500                 } else {
8501                         r->hardware_id = NULL;
8502                 }
8503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8504                 if (_ptr_provider) {
8505                         NDR_PULL_ALLOC(ndr, r->provider);
8506                 } else {
8507                         r->provider = NULL;
8508                 }
8509         }
8510         if (ndr_flags & NDR_BUFFERS) {
8511                 if (r->driver_name) {
8512                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8513                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8516                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8517                                 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));
8518                         }
8519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8520                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8522                 }
8523                 if (r->architecture) {
8524                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8525                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8528                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8529                                 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));
8530                         }
8531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8534                 }
8535                 if (r->driver_path) {
8536                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8537                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8540                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8541                                 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));
8542                         }
8543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8546                 }
8547                 if (r->data_file) {
8548                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8549                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8552                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8553                                 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));
8554                         }
8555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8558                 }
8559                 if (r->config_file) {
8560                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8561                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8564                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8565                                 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));
8566                         }
8567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8570                 }
8571                 if (r->help_file) {
8572                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8573                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8574                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8575                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8576                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8577                                 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));
8578                         }
8579                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8580                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8581                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8582                 }
8583                 if (r->monitor_name) {
8584                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8585                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8588                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8589                                 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));
8590                         }
8591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8594                 }
8595                 if (r->default_datatype) {
8596                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8597                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8600                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8601                                 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));
8602                         }
8603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8606                 }
8607                 if (r->dependent_files) {
8608                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8609                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8610                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8612                 }
8613                 if (r->previous_names) {
8614                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8615                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8616                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8618                 }
8619                 if (r->manufacturer_name) {
8620                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8621                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8623                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8624                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8625                                 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));
8626                         }
8627                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8628                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8630                 }
8631                 if (r->manufacturer_url) {
8632                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8633                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8634                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8635                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8636                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8637                                 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));
8638                         }
8639                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8640                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8642                 }
8643                 if (r->hardware_id) {
8644                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8645                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8646                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8647                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8648                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8649                                 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));
8650                         }
8651                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8652                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8654                 }
8655                 if (r->provider) {
8656                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8657                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8658                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8659                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8660                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8661                                 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));
8662                         }
8663                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8664                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8665                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8666                 }
8667         }
8668         return NDR_ERR_SUCCESS;
8669 }
8670
8671 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8672 {
8673         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8674         ndr->depth++;
8675         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8676         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8677         ndr->depth++;
8678         if (r->driver_name) {
8679                 ndr_print_string(ndr, "driver_name", r->driver_name);
8680         }
8681         ndr->depth--;
8682         ndr_print_ptr(ndr, "architecture", r->architecture);
8683         ndr->depth++;
8684         if (r->architecture) {
8685                 ndr_print_string(ndr, "architecture", r->architecture);
8686         }
8687         ndr->depth--;
8688         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8689         ndr->depth++;
8690         if (r->driver_path) {
8691                 ndr_print_string(ndr, "driver_path", r->driver_path);
8692         }
8693         ndr->depth--;
8694         ndr_print_ptr(ndr, "data_file", r->data_file);
8695         ndr->depth++;
8696         if (r->data_file) {
8697                 ndr_print_string(ndr, "data_file", r->data_file);
8698         }
8699         ndr->depth--;
8700         ndr_print_ptr(ndr, "config_file", r->config_file);
8701         ndr->depth++;
8702         if (r->config_file) {
8703                 ndr_print_string(ndr, "config_file", r->config_file);
8704         }
8705         ndr->depth--;
8706         ndr_print_ptr(ndr, "help_file", r->help_file);
8707         ndr->depth++;
8708         if (r->help_file) {
8709                 ndr_print_string(ndr, "help_file", r->help_file);
8710         }
8711         ndr->depth--;
8712         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8713         ndr->depth++;
8714         if (r->monitor_name) {
8715                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8716         }
8717         ndr->depth--;
8718         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8719         ndr->depth++;
8720         if (r->default_datatype) {
8721                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8722         }
8723         ndr->depth--;
8724         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);
8725         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8726         ndr->depth++;
8727         if (r->dependent_files) {
8728                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8729         }
8730         ndr->depth--;
8731         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);
8732         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8733         ndr->depth++;
8734         if (r->previous_names) {
8735                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8736         }
8737         ndr->depth--;
8738         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8739         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8740         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8741         ndr->depth++;
8742         if (r->manufacturer_name) {
8743                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8744         }
8745         ndr->depth--;
8746         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8747         ndr->depth++;
8748         if (r->manufacturer_url) {
8749                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8750         }
8751         ndr->depth--;
8752         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8753         ndr->depth++;
8754         if (r->hardware_id) {
8755                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8756         }
8757         ndr->depth--;
8758         ndr_print_ptr(ndr, "provider", r->provider);
8759         ndr->depth++;
8760         if (r->provider) {
8761                 ndr_print_string(ndr, "provider", r->provider);
8762         }
8763         ndr->depth--;
8764         ndr->depth--;
8765 }
8766
8767 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8768 {
8769         if (ndr_flags & NDR_SCALARS) {
8770                 NDR_CHECK(ndr_push_align(ndr, 8));
8771                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8773                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8776                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8784                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8785                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8793                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8798                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8800         }
8801         if (ndr_flags & NDR_BUFFERS) {
8802                 if (r->driver_name) {
8803                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8804                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8806                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8807                 }
8808                 if (r->architecture) {
8809                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8810                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8811                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8812                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8813                 }
8814                 if (r->driver_path) {
8815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8819                 }
8820                 if (r->data_file) {
8821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8824                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8825                 }
8826                 if (r->config_file) {
8827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8830                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8831                 }
8832                 if (r->help_file) {
8833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8836                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8837                 }
8838                 if (r->monitor_name) {
8839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8843                 }
8844                 if (r->default_datatype) {
8845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8848                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8849                 }
8850                 if (r->dependent_files) {
8851                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8852                 }
8853                 if (r->previous_names) {
8854                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8855                 }
8856                 if (r->manufacturer_name) {
8857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8861                 }
8862                 if (r->manufacturer_url) {
8863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8866                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8867                 }
8868                 if (r->hardware_id) {
8869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8872                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8873                 }
8874                 if (r->provider) {
8875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8876                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8877                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8878                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8879                 }
8880                 if (r->print_processor) {
8881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8883                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8884                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8885                 }
8886                 if (r->vendor_setup) {
8887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8890                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8891                 }
8892                 if (r->color_profiles) {
8893                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8894                 }
8895                 if (r->inf_path) {
8896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8899                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8900                 }
8901                 if (r->core_driver_dependencies) {
8902                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8903                 }
8904         }
8905         return NDR_ERR_SUCCESS;
8906 }
8907
8908 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
8909 {
8910         uint32_t _ptr_driver_name;
8911         TALLOC_CTX *_mem_save_driver_name_0;
8912         uint32_t _ptr_architecture;
8913         TALLOC_CTX *_mem_save_architecture_0;
8914         uint32_t _ptr_driver_path;
8915         TALLOC_CTX *_mem_save_driver_path_0;
8916         uint32_t _ptr_data_file;
8917         TALLOC_CTX *_mem_save_data_file_0;
8918         uint32_t _ptr_config_file;
8919         TALLOC_CTX *_mem_save_config_file_0;
8920         uint32_t _ptr_help_file;
8921         TALLOC_CTX *_mem_save_help_file_0;
8922         uint32_t _ptr_monitor_name;
8923         TALLOC_CTX *_mem_save_monitor_name_0;
8924         uint32_t _ptr_default_datatype;
8925         TALLOC_CTX *_mem_save_default_datatype_0;
8926         uint32_t _ptr_dependent_files;
8927         TALLOC_CTX *_mem_save_dependent_files_0;
8928         uint32_t _ptr_previous_names;
8929         TALLOC_CTX *_mem_save_previous_names_0;
8930         uint32_t _ptr_manufacturer_name;
8931         TALLOC_CTX *_mem_save_manufacturer_name_0;
8932         uint32_t _ptr_manufacturer_url;
8933         TALLOC_CTX *_mem_save_manufacturer_url_0;
8934         uint32_t _ptr_hardware_id;
8935         TALLOC_CTX *_mem_save_hardware_id_0;
8936         uint32_t _ptr_provider;
8937         TALLOC_CTX *_mem_save_provider_0;
8938         uint32_t _ptr_print_processor;
8939         TALLOC_CTX *_mem_save_print_processor_0;
8940         uint32_t _ptr_vendor_setup;
8941         TALLOC_CTX *_mem_save_vendor_setup_0;
8942         uint32_t _ptr_color_profiles;
8943         TALLOC_CTX *_mem_save_color_profiles_0;
8944         uint32_t _ptr_inf_path;
8945         TALLOC_CTX *_mem_save_inf_path_0;
8946         uint32_t _ptr_core_driver_dependencies;
8947         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
8948         if (ndr_flags & NDR_SCALARS) {
8949                 NDR_CHECK(ndr_pull_align(ndr, 8));
8950                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8952                 if (_ptr_driver_name) {
8953                         NDR_PULL_ALLOC(ndr, r->driver_name);
8954                 } else {
8955                         r->driver_name = NULL;
8956                 }
8957                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8958                 if (_ptr_architecture) {
8959                         NDR_PULL_ALLOC(ndr, r->architecture);
8960                 } else {
8961                         r->architecture = NULL;
8962                 }
8963                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8964                 if (_ptr_driver_path) {
8965                         NDR_PULL_ALLOC(ndr, r->driver_path);
8966                 } else {
8967                         r->driver_path = NULL;
8968                 }
8969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8970                 if (_ptr_data_file) {
8971                         NDR_PULL_ALLOC(ndr, r->data_file);
8972                 } else {
8973                         r->data_file = NULL;
8974                 }
8975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8976                 if (_ptr_config_file) {
8977                         NDR_PULL_ALLOC(ndr, r->config_file);
8978                 } else {
8979                         r->config_file = NULL;
8980                 }
8981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8982                 if (_ptr_help_file) {
8983                         NDR_PULL_ALLOC(ndr, r->help_file);
8984                 } else {
8985                         r->help_file = NULL;
8986                 }
8987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8988                 if (_ptr_monitor_name) {
8989                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8990                 } else {
8991                         r->monitor_name = NULL;
8992                 }
8993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8994                 if (_ptr_default_datatype) {
8995                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8996                 } else {
8997                         r->default_datatype = NULL;
8998                 }
8999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9001                 if (_ptr_dependent_files) {
9002                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9003                 } else {
9004                         r->dependent_files = NULL;
9005                 }
9006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9008                 if (_ptr_previous_names) {
9009                         NDR_PULL_ALLOC(ndr, r->previous_names);
9010                 } else {
9011                         r->previous_names = NULL;
9012                 }
9013                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9014                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9016                 if (_ptr_manufacturer_name) {
9017                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9018                 } else {
9019                         r->manufacturer_name = NULL;
9020                 }
9021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9022                 if (_ptr_manufacturer_url) {
9023                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9024                 } else {
9025                         r->manufacturer_url = NULL;
9026                 }
9027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9028                 if (_ptr_hardware_id) {
9029                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9030                 } else {
9031                         r->hardware_id = NULL;
9032                 }
9033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9034                 if (_ptr_provider) {
9035                         NDR_PULL_ALLOC(ndr, r->provider);
9036                 } else {
9037                         r->provider = NULL;
9038                 }
9039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9040                 if (_ptr_print_processor) {
9041                         NDR_PULL_ALLOC(ndr, r->print_processor);
9042                 } else {
9043                         r->print_processor = NULL;
9044                 }
9045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9046                 if (_ptr_vendor_setup) {
9047                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9048                 } else {
9049                         r->vendor_setup = NULL;
9050                 }
9051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9053                 if (_ptr_color_profiles) {
9054                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9055                 } else {
9056                         r->color_profiles = NULL;
9057                 }
9058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9059                 if (_ptr_inf_path) {
9060                         NDR_PULL_ALLOC(ndr, r->inf_path);
9061                 } else {
9062                         r->inf_path = NULL;
9063                 }
9064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9067                 if (_ptr_core_driver_dependencies) {
9068                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9069                 } else {
9070                         r->core_driver_dependencies = NULL;
9071                 }
9072                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9073                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9074         }
9075         if (ndr_flags & NDR_BUFFERS) {
9076                 if (r->driver_name) {
9077                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9078                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9081                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9082                                 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));
9083                         }
9084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9087                 }
9088                 if (r->architecture) {
9089                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9090                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9091                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9092                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9093                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9094                                 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));
9095                         }
9096                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9097                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9099                 }
9100                 if (r->driver_path) {
9101                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9102                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9105                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9106                                 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));
9107                         }
9108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9111                 }
9112                 if (r->data_file) {
9113                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9114                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9115                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9116                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9117                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9118                                 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));
9119                         }
9120                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9123                 }
9124                 if (r->config_file) {
9125                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9126                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9127                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9128                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9129                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9130                                 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));
9131                         }
9132                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9133                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9135                 }
9136                 if (r->help_file) {
9137                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9138                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9141                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9142                                 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));
9143                         }
9144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9147                 }
9148                 if (r->monitor_name) {
9149                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9150                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9153                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9154                                 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));
9155                         }
9156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9159                 }
9160                 if (r->default_datatype) {
9161                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9162                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9163                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9164                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9165                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9166                                 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));
9167                         }
9168                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9169                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9171                 }
9172                 if (r->dependent_files) {
9173                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9174                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9175                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9177                 }
9178                 if (r->previous_names) {
9179                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9180                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9181                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9183                 }
9184                 if (r->manufacturer_name) {
9185                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9186                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9189                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9190                                 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));
9191                         }
9192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9195                 }
9196                 if (r->manufacturer_url) {
9197                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9198                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9201                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9202                                 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));
9203                         }
9204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9207                 }
9208                 if (r->hardware_id) {
9209                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9210                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9213                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9214                                 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));
9215                         }
9216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9219                 }
9220                 if (r->provider) {
9221                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9222                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9224                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9225                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9226                                 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));
9227                         }
9228                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9229                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9231                 }
9232                 if (r->print_processor) {
9233                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9234                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9236                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9237                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9238                                 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));
9239                         }
9240                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9241                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9243                 }
9244                 if (r->vendor_setup) {
9245                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9246                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9248                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9249                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9250                                 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));
9251                         }
9252                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9253                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9255                 }
9256                 if (r->color_profiles) {
9257                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9258                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9259                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9261                 }
9262                 if (r->inf_path) {
9263                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9264                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9267                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9268                                 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));
9269                         }
9270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9273                 }
9274                 if (r->core_driver_dependencies) {
9275                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9276                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9277                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9279                 }
9280         }
9281         return NDR_ERR_SUCCESS;
9282 }
9283
9284 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9285 {
9286         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9287         ndr->depth++;
9288         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9289         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9290         ndr->depth++;
9291         if (r->driver_name) {
9292                 ndr_print_string(ndr, "driver_name", r->driver_name);
9293         }
9294         ndr->depth--;
9295         ndr_print_ptr(ndr, "architecture", r->architecture);
9296         ndr->depth++;
9297         if (r->architecture) {
9298                 ndr_print_string(ndr, "architecture", r->architecture);
9299         }
9300         ndr->depth--;
9301         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9302         ndr->depth++;
9303         if (r->driver_path) {
9304                 ndr_print_string(ndr, "driver_path", r->driver_path);
9305         }
9306         ndr->depth--;
9307         ndr_print_ptr(ndr, "data_file", r->data_file);
9308         ndr->depth++;
9309         if (r->data_file) {
9310                 ndr_print_string(ndr, "data_file", r->data_file);
9311         }
9312         ndr->depth--;
9313         ndr_print_ptr(ndr, "config_file", r->config_file);
9314         ndr->depth++;
9315         if (r->config_file) {
9316                 ndr_print_string(ndr, "config_file", r->config_file);
9317         }
9318         ndr->depth--;
9319         ndr_print_ptr(ndr, "help_file", r->help_file);
9320         ndr->depth++;
9321         if (r->help_file) {
9322                 ndr_print_string(ndr, "help_file", r->help_file);
9323         }
9324         ndr->depth--;
9325         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9326         ndr->depth++;
9327         if (r->monitor_name) {
9328                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9329         }
9330         ndr->depth--;
9331         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9332         ndr->depth++;
9333         if (r->default_datatype) {
9334                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9335         }
9336         ndr->depth--;
9337         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);
9338         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9339         ndr->depth++;
9340         if (r->dependent_files) {
9341                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9342         }
9343         ndr->depth--;
9344         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);
9345         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9346         ndr->depth++;
9347         if (r->previous_names) {
9348                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9349         }
9350         ndr->depth--;
9351         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9352         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9353         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9354         ndr->depth++;
9355         if (r->manufacturer_name) {
9356                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9357         }
9358         ndr->depth--;
9359         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9360         ndr->depth++;
9361         if (r->manufacturer_url) {
9362                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9363         }
9364         ndr->depth--;
9365         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9366         ndr->depth++;
9367         if (r->hardware_id) {
9368                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9369         }
9370         ndr->depth--;
9371         ndr_print_ptr(ndr, "provider", r->provider);
9372         ndr->depth++;
9373         if (r->provider) {
9374                 ndr_print_string(ndr, "provider", r->provider);
9375         }
9376         ndr->depth--;
9377         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9378         ndr->depth++;
9379         if (r->print_processor) {
9380                 ndr_print_string(ndr, "print_processor", r->print_processor);
9381         }
9382         ndr->depth--;
9383         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9384         ndr->depth++;
9385         if (r->vendor_setup) {
9386                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9387         }
9388         ndr->depth--;
9389         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);
9390         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9391         ndr->depth++;
9392         if (r->color_profiles) {
9393                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9394         }
9395         ndr->depth--;
9396         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9397         ndr->depth++;
9398         if (r->inf_path) {
9399                 ndr_print_string(ndr, "inf_path", r->inf_path);
9400         }
9401         ndr->depth--;
9402         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9403         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);
9404         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9405         ndr->depth++;
9406         if (r->core_driver_dependencies) {
9407                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9408         }
9409         ndr->depth--;
9410         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9411         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9412         ndr->depth--;
9413 }
9414
9415 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9416 {
9417         if (ndr_flags & NDR_SCALARS) {
9418                 int level = ndr_push_get_switch_value(ndr, r);
9419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9420                 switch (level) {
9421                         case 1: {
9422                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9423                         break; }
9424
9425                         case 2: {
9426                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9427                         break; }
9428
9429                         case 3: {
9430                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9431                         break; }
9432
9433                         case 4: {
9434                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9435                         break; }
9436
9437                         case 6: {
9438                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9439                         break; }
9440
9441                         case 8: {
9442                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9443                         break; }
9444
9445                         default:
9446                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9447                 }
9448         }
9449         if (ndr_flags & NDR_BUFFERS) {
9450                 int level = ndr_push_get_switch_value(ndr, r);
9451                 switch (level) {
9452                         case 1:
9453                                 if (r->info1) {
9454                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9455                                 }
9456                         break;
9457
9458                         case 2:
9459                                 if (r->info2) {
9460                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9461                                 }
9462                         break;
9463
9464                         case 3:
9465                                 if (r->info3) {
9466                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9467                                 }
9468                         break;
9469
9470                         case 4:
9471                                 if (r->info4) {
9472                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9473                                 }
9474                         break;
9475
9476                         case 6:
9477                                 if (r->info6) {
9478                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9479                                 }
9480                         break;
9481
9482                         case 8:
9483                                 if (r->info8) {
9484                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9485                                 }
9486                         break;
9487
9488                         default:
9489                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9490                 }
9491         }
9492         return NDR_ERR_SUCCESS;
9493 }
9494
9495 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9496 {
9497         int level;
9498         uint32_t _level;
9499         TALLOC_CTX *_mem_save_info1_0;
9500         TALLOC_CTX *_mem_save_info2_0;
9501         TALLOC_CTX *_mem_save_info3_0;
9502         TALLOC_CTX *_mem_save_info4_0;
9503         TALLOC_CTX *_mem_save_info6_0;
9504         TALLOC_CTX *_mem_save_info8_0;
9505         level = ndr_pull_get_switch_value(ndr, r);
9506         if (ndr_flags & NDR_SCALARS) {
9507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9508                 if (_level != level) {
9509                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9510                 }
9511                 switch (level) {
9512                         case 1: {
9513                                 uint32_t _ptr_info1;
9514                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9515                                 if (_ptr_info1) {
9516                                         NDR_PULL_ALLOC(ndr, r->info1);
9517                                 } else {
9518                                         r->info1 = NULL;
9519                                 }
9520                         break; }
9521
9522                         case 2: {
9523                                 uint32_t _ptr_info2;
9524                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9525                                 if (_ptr_info2) {
9526                                         NDR_PULL_ALLOC(ndr, r->info2);
9527                                 } else {
9528                                         r->info2 = NULL;
9529                                 }
9530                         break; }
9531
9532                         case 3: {
9533                                 uint32_t _ptr_info3;
9534                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9535                                 if (_ptr_info3) {
9536                                         NDR_PULL_ALLOC(ndr, r->info3);
9537                                 } else {
9538                                         r->info3 = NULL;
9539                                 }
9540                         break; }
9541
9542                         case 4: {
9543                                 uint32_t _ptr_info4;
9544                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9545                                 if (_ptr_info4) {
9546                                         NDR_PULL_ALLOC(ndr, r->info4);
9547                                 } else {
9548                                         r->info4 = NULL;
9549                                 }
9550                         break; }
9551
9552                         case 6: {
9553                                 uint32_t _ptr_info6;
9554                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9555                                 if (_ptr_info6) {
9556                                         NDR_PULL_ALLOC(ndr, r->info6);
9557                                 } else {
9558                                         r->info6 = NULL;
9559                                 }
9560                         break; }
9561
9562                         case 8: {
9563                                 uint32_t _ptr_info8;
9564                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9565                                 if (_ptr_info8) {
9566                                         NDR_PULL_ALLOC(ndr, r->info8);
9567                                 } else {
9568                                         r->info8 = NULL;
9569                                 }
9570                         break; }
9571
9572                         default:
9573                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9574                 }
9575         }
9576         if (ndr_flags & NDR_BUFFERS) {
9577                 switch (level) {
9578                         case 1:
9579                                 if (r->info1) {
9580                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9581                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9582                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9583                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9584                                 }
9585                         break;
9586
9587                         case 2:
9588                                 if (r->info2) {
9589                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9590                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9591                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9592                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9593                                 }
9594                         break;
9595
9596                         case 3:
9597                                 if (r->info3) {
9598                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9599                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9600                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9601                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9602                                 }
9603                         break;
9604
9605                         case 4:
9606                                 if (r->info4) {
9607                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9608                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9609                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9610                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9611                                 }
9612                         break;
9613
9614                         case 6:
9615                                 if (r->info6) {
9616                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9617                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9618                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9619                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9620                                 }
9621                         break;
9622
9623                         case 8:
9624                                 if (r->info8) {
9625                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9626                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9627                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9628                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9629                                 }
9630                         break;
9631
9632                         default:
9633                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9634                 }
9635         }
9636         return NDR_ERR_SUCCESS;
9637 }
9638
9639 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9640 {
9641         int level;
9642         level = ndr_print_get_switch_value(ndr, r);
9643         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9644         switch (level) {
9645                 case 1:
9646                         ndr_print_ptr(ndr, "info1", r->info1);
9647                         ndr->depth++;
9648                         if (r->info1) {
9649                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9650                         }
9651                         ndr->depth--;
9652                 break;
9653
9654                 case 2:
9655                         ndr_print_ptr(ndr, "info2", r->info2);
9656                         ndr->depth++;
9657                         if (r->info2) {
9658                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9659                         }
9660                         ndr->depth--;
9661                 break;
9662
9663                 case 3:
9664                         ndr_print_ptr(ndr, "info3", r->info3);
9665                         ndr->depth++;
9666                         if (r->info3) {
9667                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9668                         }
9669                         ndr->depth--;
9670                 break;
9671
9672                 case 4:
9673                         ndr_print_ptr(ndr, "info4", r->info4);
9674                         ndr->depth++;
9675                         if (r->info4) {
9676                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9677                         }
9678                         ndr->depth--;
9679                 break;
9680
9681                 case 6:
9682                         ndr_print_ptr(ndr, "info6", r->info6);
9683                         ndr->depth++;
9684                         if (r->info6) {
9685                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9686                         }
9687                         ndr->depth--;
9688                 break;
9689
9690                 case 8:
9691                         ndr_print_ptr(ndr, "info8", r->info8);
9692                         ndr->depth++;
9693                         if (r->info8) {
9694                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9695                         }
9696                         ndr->depth--;
9697                 break;
9698
9699                 default:
9700                         ndr_print_bad_level(ndr, name, level);
9701         }
9702 }
9703
9704 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9705 {
9706         if (ndr_flags & NDR_SCALARS) {
9707                 NDR_CHECK(ndr_push_align(ndr, 4));
9708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9709                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9710                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9711         }
9712         if (ndr_flags & NDR_BUFFERS) {
9713                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9714         }
9715         return NDR_ERR_SUCCESS;
9716 }
9717
9718 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9719 {
9720         if (ndr_flags & NDR_SCALARS) {
9721                 NDR_CHECK(ndr_pull_align(ndr, 4));
9722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9723                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9724                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9725         }
9726         if (ndr_flags & NDR_BUFFERS) {
9727                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9728         }
9729         return NDR_ERR_SUCCESS;
9730 }
9731
9732 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9733 {
9734         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9735         ndr->depth++;
9736         ndr_print_uint32(ndr, "level", r->level);
9737         ndr_print_set_switch_value(ndr, &r->info, r->level);
9738         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9739         ndr->depth--;
9740 }
9741
9742 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9743 {
9744         if (ndr_flags & NDR_SCALARS) {
9745                 NDR_CHECK(ndr_push_align(ndr, 4));
9746                 {
9747                         uint32_t _flags_save_string = ndr->flags;
9748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9750                         ndr->flags = _flags_save_string;
9751                 }
9752         }
9753         if (ndr_flags & NDR_BUFFERS) {
9754                 {
9755                         uint32_t _flags_save_string = ndr->flags;
9756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9757                         if (r->driver_name) {
9758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9760                         }
9761                         ndr->flags = _flags_save_string;
9762                 }
9763         }
9764         return NDR_ERR_SUCCESS;
9765 }
9766
9767 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9768 {
9769         uint32_t _ptr_driver_name;
9770         TALLOC_CTX *_mem_save_driver_name_0;
9771         if (ndr_flags & NDR_SCALARS) {
9772                 NDR_CHECK(ndr_pull_align(ndr, 4));
9773                 {
9774                         uint32_t _flags_save_string = ndr->flags;
9775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9777                         if (_ptr_driver_name) {
9778                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9780                         } else {
9781                                 r->driver_name = NULL;
9782                         }
9783                         ndr->flags = _flags_save_string;
9784                 }
9785         }
9786         if (ndr_flags & NDR_BUFFERS) {
9787                 {
9788                         uint32_t _flags_save_string = ndr->flags;
9789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9790                         if (r->driver_name) {
9791                                 uint32_t _relative_save_offset;
9792                                 _relative_save_offset = ndr->offset;
9793                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9794                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9795                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9796                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9797                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9798                                 ndr->offset = _relative_save_offset;
9799                         }
9800                         ndr->flags = _flags_save_string;
9801                 }
9802         }
9803         return NDR_ERR_SUCCESS;
9804 }
9805
9806 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9807 {
9808         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9809         ndr->depth++;
9810         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9811         ndr->depth++;
9812         if (r->driver_name) {
9813                 ndr_print_string(ndr, "driver_name", r->driver_name);
9814         }
9815         ndr->depth--;
9816         ndr->depth--;
9817 }
9818
9819 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9820 {
9821         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9822 }
9823
9824 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9825 {
9826         if (ndr_flags & NDR_SCALARS) {
9827                 NDR_CHECK(ndr_push_align(ndr, 4));
9828                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9829                 {
9830                         uint32_t _flags_save_string = ndr->flags;
9831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9832                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9833                         ndr->flags = _flags_save_string;
9834                 }
9835                 {
9836                         uint32_t _flags_save_string = ndr->flags;
9837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9838                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9839                         ndr->flags = _flags_save_string;
9840                 }
9841                 {
9842                         uint32_t _flags_save_string = ndr->flags;
9843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9844                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9845                         ndr->flags = _flags_save_string;
9846                 }
9847                 {
9848                         uint32_t _flags_save_string = ndr->flags;
9849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9850                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9851                         ndr->flags = _flags_save_string;
9852                 }
9853                 {
9854                         uint32_t _flags_save_string = ndr->flags;
9855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9856                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9857                         ndr->flags = _flags_save_string;
9858                 }
9859         }
9860         if (ndr_flags & NDR_BUFFERS) {
9861                 {
9862                         uint32_t _flags_save_string = ndr->flags;
9863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9864                         if (r->driver_name) {
9865                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9866                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9867                         }
9868                         ndr->flags = _flags_save_string;
9869                 }
9870                 {
9871                         uint32_t _flags_save_string = ndr->flags;
9872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9873                         if (r->architecture) {
9874                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9875                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9876                         }
9877                         ndr->flags = _flags_save_string;
9878                 }
9879                 {
9880                         uint32_t _flags_save_string = ndr->flags;
9881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9882                         if (r->driver_path) {
9883                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9884                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9885                         }
9886                         ndr->flags = _flags_save_string;
9887                 }
9888                 {
9889                         uint32_t _flags_save_string = ndr->flags;
9890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9891                         if (r->data_file) {
9892                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9893                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9894                         }
9895                         ndr->flags = _flags_save_string;
9896                 }
9897                 {
9898                         uint32_t _flags_save_string = ndr->flags;
9899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9900                         if (r->config_file) {
9901                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9902                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9903                         }
9904                         ndr->flags = _flags_save_string;
9905                 }
9906         }
9907         return NDR_ERR_SUCCESS;
9908 }
9909
9910 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
9911 {
9912         uint32_t _ptr_driver_name;
9913         TALLOC_CTX *_mem_save_driver_name_0;
9914         uint32_t _ptr_architecture;
9915         TALLOC_CTX *_mem_save_architecture_0;
9916         uint32_t _ptr_driver_path;
9917         TALLOC_CTX *_mem_save_driver_path_0;
9918         uint32_t _ptr_data_file;
9919         TALLOC_CTX *_mem_save_data_file_0;
9920         uint32_t _ptr_config_file;
9921         TALLOC_CTX *_mem_save_config_file_0;
9922         if (ndr_flags & NDR_SCALARS) {
9923                 NDR_CHECK(ndr_pull_align(ndr, 4));
9924                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9925                 {
9926                         uint32_t _flags_save_string = ndr->flags;
9927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9929                         if (_ptr_driver_name) {
9930                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9932                         } else {
9933                                 r->driver_name = NULL;
9934                         }
9935                         ndr->flags = _flags_save_string;
9936                 }
9937                 {
9938                         uint32_t _flags_save_string = ndr->flags;
9939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9940                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9941                         if (_ptr_architecture) {
9942                                 NDR_PULL_ALLOC(ndr, r->architecture);
9943                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9944                         } else {
9945                                 r->architecture = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9953                         if (_ptr_driver_path) {
9954                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9955                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9956                         } else {
9957                                 r->driver_path = NULL;
9958                         }
9959                         ndr->flags = _flags_save_string;
9960                 }
9961                 {
9962                         uint32_t _flags_save_string = ndr->flags;
9963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9964                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9965                         if (_ptr_data_file) {
9966                                 NDR_PULL_ALLOC(ndr, r->data_file);
9967                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9968                         } else {
9969                                 r->data_file = NULL;
9970                         }
9971                         ndr->flags = _flags_save_string;
9972                 }
9973                 {
9974                         uint32_t _flags_save_string = ndr->flags;
9975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9976                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9977                         if (_ptr_config_file) {
9978                                 NDR_PULL_ALLOC(ndr, r->config_file);
9979                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9980                         } else {
9981                                 r->config_file = NULL;
9982                         }
9983                         ndr->flags = _flags_save_string;
9984                 }
9985         }
9986         if (ndr_flags & NDR_BUFFERS) {
9987                 {
9988                         uint32_t _flags_save_string = ndr->flags;
9989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9990                         if (r->driver_name) {
9991                                 uint32_t _relative_save_offset;
9992                                 _relative_save_offset = ndr->offset;
9993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9994                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9995                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9998                                 ndr->offset = _relative_save_offset;
9999                         }
10000                         ndr->flags = _flags_save_string;
10001                 }
10002                 {
10003                         uint32_t _flags_save_string = ndr->flags;
10004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10005                         if (r->architecture) {
10006                                 uint32_t _relative_save_offset;
10007                                 _relative_save_offset = ndr->offset;
10008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10009                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10010                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10013                                 ndr->offset = _relative_save_offset;
10014                         }
10015                         ndr->flags = _flags_save_string;
10016                 }
10017                 {
10018                         uint32_t _flags_save_string = ndr->flags;
10019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10020                         if (r->driver_path) {
10021                                 uint32_t _relative_save_offset;
10022                                 _relative_save_offset = ndr->offset;
10023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10024                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10025                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10028                                 ndr->offset = _relative_save_offset;
10029                         }
10030                         ndr->flags = _flags_save_string;
10031                 }
10032                 {
10033                         uint32_t _flags_save_string = ndr->flags;
10034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10035                         if (r->data_file) {
10036                                 uint32_t _relative_save_offset;
10037                                 _relative_save_offset = ndr->offset;
10038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10039                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10040                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10043                                 ndr->offset = _relative_save_offset;
10044                         }
10045                         ndr->flags = _flags_save_string;
10046                 }
10047                 {
10048                         uint32_t _flags_save_string = ndr->flags;
10049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10050                         if (r->config_file) {
10051                                 uint32_t _relative_save_offset;
10052                                 _relative_save_offset = ndr->offset;
10053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10054                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10055                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10058                                 ndr->offset = _relative_save_offset;
10059                         }
10060                         ndr->flags = _flags_save_string;
10061                 }
10062         }
10063         return NDR_ERR_SUCCESS;
10064 }
10065
10066 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10067 {
10068         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10069         ndr->depth++;
10070         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10071         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10072         ndr->depth++;
10073         if (r->driver_name) {
10074                 ndr_print_string(ndr, "driver_name", r->driver_name);
10075         }
10076         ndr->depth--;
10077         ndr_print_ptr(ndr, "architecture", r->architecture);
10078         ndr->depth++;
10079         if (r->architecture) {
10080                 ndr_print_string(ndr, "architecture", r->architecture);
10081         }
10082         ndr->depth--;
10083         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10084         ndr->depth++;
10085         if (r->driver_path) {
10086                 ndr_print_string(ndr, "driver_path", r->driver_path);
10087         }
10088         ndr->depth--;
10089         ndr_print_ptr(ndr, "data_file", r->data_file);
10090         ndr->depth++;
10091         if (r->data_file) {
10092                 ndr_print_string(ndr, "data_file", r->data_file);
10093         }
10094         ndr->depth--;
10095         ndr_print_ptr(ndr, "config_file", r->config_file);
10096         ndr->depth++;
10097         if (r->config_file) {
10098                 ndr_print_string(ndr, "config_file", r->config_file);
10099         }
10100         ndr->depth--;
10101         ndr->depth--;
10102 }
10103
10104 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10105 {
10106         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10107 }
10108
10109 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10110 {
10111         if (ndr_flags & NDR_SCALARS) {
10112                 NDR_CHECK(ndr_push_align(ndr, 4));
10113                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10114                 {
10115                         uint32_t _flags_save_string = ndr->flags;
10116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10117                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10118                         ndr->flags = _flags_save_string;
10119                 }
10120                 {
10121                         uint32_t _flags_save_string = ndr->flags;
10122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10123                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10124                         ndr->flags = _flags_save_string;
10125                 }
10126                 {
10127                         uint32_t _flags_save_string = ndr->flags;
10128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10129                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10130                         ndr->flags = _flags_save_string;
10131                 }
10132                 {
10133                         uint32_t _flags_save_string = ndr->flags;
10134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10135                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10136                         ndr->flags = _flags_save_string;
10137                 }
10138                 {
10139                         uint32_t _flags_save_string = ndr->flags;
10140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10141                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10142                         ndr->flags = _flags_save_string;
10143                 }
10144                 {
10145                         uint32_t _flags_save_string = ndr->flags;
10146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10147                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10148                         ndr->flags = _flags_save_string;
10149                 }
10150                 {
10151                         uint32_t _flags_save_string_array = ndr->flags;
10152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10153                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10154                         ndr->flags = _flags_save_string_array;
10155                 }
10156                 {
10157                         uint32_t _flags_save_string = ndr->flags;
10158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10159                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10160                         ndr->flags = _flags_save_string;
10161                 }
10162                 {
10163                         uint32_t _flags_save_string = ndr->flags;
10164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10165                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10166                         ndr->flags = _flags_save_string;
10167                 }
10168         }
10169         if (ndr_flags & NDR_BUFFERS) {
10170                 {
10171                         uint32_t _flags_save_string = ndr->flags;
10172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10173                         if (r->driver_name) {
10174                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10175                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10176                         }
10177                         ndr->flags = _flags_save_string;
10178                 }
10179                 {
10180                         uint32_t _flags_save_string = ndr->flags;
10181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10182                         if (r->architecture) {
10183                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10184                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10185                         }
10186                         ndr->flags = _flags_save_string;
10187                 }
10188                 {
10189                         uint32_t _flags_save_string = ndr->flags;
10190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10191                         if (r->driver_path) {
10192                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10193                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10194                         }
10195                         ndr->flags = _flags_save_string;
10196                 }
10197                 {
10198                         uint32_t _flags_save_string = ndr->flags;
10199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10200                         if (r->data_file) {
10201                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10202                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10203                         }
10204                         ndr->flags = _flags_save_string;
10205                 }
10206                 {
10207                         uint32_t _flags_save_string = ndr->flags;
10208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10209                         if (r->config_file) {
10210                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10211                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10212                         }
10213                         ndr->flags = _flags_save_string;
10214                 }
10215                 {
10216                         uint32_t _flags_save_string = ndr->flags;
10217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10218                         if (r->help_file) {
10219                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10220                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10221                         }
10222                         ndr->flags = _flags_save_string;
10223                 }
10224                 {
10225                         uint32_t _flags_save_string_array = ndr->flags;
10226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10227                         if (r->dependent_files) {
10228                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10229                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10230                         }
10231                         ndr->flags = _flags_save_string_array;
10232                 }
10233                 {
10234                         uint32_t _flags_save_string = ndr->flags;
10235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10236                         if (r->monitor_name) {
10237                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10238                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10239                         }
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         if (r->default_datatype) {
10246                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10247                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10248                         }
10249                         ndr->flags = _flags_save_string;
10250                 }
10251         }
10252         return NDR_ERR_SUCCESS;
10253 }
10254
10255 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10256 {
10257         uint32_t _ptr_driver_name;
10258         TALLOC_CTX *_mem_save_driver_name_0;
10259         uint32_t _ptr_architecture;
10260         TALLOC_CTX *_mem_save_architecture_0;
10261         uint32_t _ptr_driver_path;
10262         TALLOC_CTX *_mem_save_driver_path_0;
10263         uint32_t _ptr_data_file;
10264         TALLOC_CTX *_mem_save_data_file_0;
10265         uint32_t _ptr_config_file;
10266         TALLOC_CTX *_mem_save_config_file_0;
10267         uint32_t _ptr_help_file;
10268         TALLOC_CTX *_mem_save_help_file_0;
10269         uint32_t _ptr_dependent_files;
10270         TALLOC_CTX *_mem_save_dependent_files_0;
10271         uint32_t _ptr_monitor_name;
10272         TALLOC_CTX *_mem_save_monitor_name_0;
10273         uint32_t _ptr_default_datatype;
10274         TALLOC_CTX *_mem_save_default_datatype_0;
10275         if (ndr_flags & NDR_SCALARS) {
10276                 NDR_CHECK(ndr_pull_align(ndr, 4));
10277                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10278                 {
10279                         uint32_t _flags_save_string = ndr->flags;
10280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10281                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10282                         if (_ptr_driver_name) {
10283                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10284                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10285                         } else {
10286                                 r->driver_name = NULL;
10287                         }
10288                         ndr->flags = _flags_save_string;
10289                 }
10290                 {
10291                         uint32_t _flags_save_string = ndr->flags;
10292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10293                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10294                         if (_ptr_architecture) {
10295                                 NDR_PULL_ALLOC(ndr, r->architecture);
10296                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10297                         } else {
10298                                 r->architecture = NULL;
10299                         }
10300                         ndr->flags = _flags_save_string;
10301                 }
10302                 {
10303                         uint32_t _flags_save_string = ndr->flags;
10304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10306                         if (_ptr_driver_path) {
10307                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10309                         } else {
10310                                 r->driver_path = NULL;
10311                         }
10312                         ndr->flags = _flags_save_string;
10313                 }
10314                 {
10315                         uint32_t _flags_save_string = ndr->flags;
10316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10318                         if (_ptr_data_file) {
10319                                 NDR_PULL_ALLOC(ndr, r->data_file);
10320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10321                         } else {
10322                                 r->data_file = NULL;
10323                         }
10324                         ndr->flags = _flags_save_string;
10325                 }
10326                 {
10327                         uint32_t _flags_save_string = ndr->flags;
10328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10330                         if (_ptr_config_file) {
10331                                 NDR_PULL_ALLOC(ndr, r->config_file);
10332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10333                         } else {
10334                                 r->config_file = NULL;
10335                         }
10336                         ndr->flags = _flags_save_string;
10337                 }
10338                 {
10339                         uint32_t _flags_save_string = ndr->flags;
10340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10342                         if (_ptr_help_file) {
10343                                 NDR_PULL_ALLOC(ndr, r->help_file);
10344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10345                         } else {
10346                                 r->help_file = NULL;
10347                         }
10348                         ndr->flags = _flags_save_string;
10349                 }
10350                 {
10351                         uint32_t _flags_save_string_array = ndr->flags;
10352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10354                         if (_ptr_dependent_files) {
10355                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10357                         } else {
10358                                 r->dependent_files = NULL;
10359                         }
10360                         ndr->flags = _flags_save_string_array;
10361                 }
10362                 {
10363                         uint32_t _flags_save_string = ndr->flags;
10364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10366                         if (_ptr_monitor_name) {
10367                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10369                         } else {
10370                                 r->monitor_name = NULL;
10371                         }
10372                         ndr->flags = _flags_save_string;
10373                 }
10374                 {
10375                         uint32_t _flags_save_string = ndr->flags;
10376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10377                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10378                         if (_ptr_default_datatype) {
10379                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10380                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10381                         } else {
10382                                 r->default_datatype = NULL;
10383                         }
10384                         ndr->flags = _flags_save_string;
10385                 }
10386         }
10387         if (ndr_flags & NDR_BUFFERS) {
10388                 {
10389                         uint32_t _flags_save_string = ndr->flags;
10390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10391                         if (r->driver_name) {
10392                                 uint32_t _relative_save_offset;
10393                                 _relative_save_offset = ndr->offset;
10394                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10395                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10396                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10397                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10399                                 ndr->offset = _relative_save_offset;
10400                         }
10401                         ndr->flags = _flags_save_string;
10402                 }
10403                 {
10404                         uint32_t _flags_save_string = ndr->flags;
10405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10406                         if (r->architecture) {
10407                                 uint32_t _relative_save_offset;
10408                                 _relative_save_offset = ndr->offset;
10409                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10410                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10411                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10412                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10413                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10414                                 ndr->offset = _relative_save_offset;
10415                         }
10416                         ndr->flags = _flags_save_string;
10417                 }
10418                 {
10419                         uint32_t _flags_save_string = ndr->flags;
10420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10421                         if (r->driver_path) {
10422                                 uint32_t _relative_save_offset;
10423                                 _relative_save_offset = ndr->offset;
10424                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10425                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10426                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10427                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10428                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10429                                 ndr->offset = _relative_save_offset;
10430                         }
10431                         ndr->flags = _flags_save_string;
10432                 }
10433                 {
10434                         uint32_t _flags_save_string = ndr->flags;
10435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10436                         if (r->data_file) {
10437                                 uint32_t _relative_save_offset;
10438                                 _relative_save_offset = ndr->offset;
10439                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10440                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10441                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10442                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10443                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10444                                 ndr->offset = _relative_save_offset;
10445                         }
10446                         ndr->flags = _flags_save_string;
10447                 }
10448                 {
10449                         uint32_t _flags_save_string = ndr->flags;
10450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10451                         if (r->config_file) {
10452                                 uint32_t _relative_save_offset;
10453                                 _relative_save_offset = ndr->offset;
10454                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10455                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10456                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10457                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10458                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10459                                 ndr->offset = _relative_save_offset;
10460                         }
10461                         ndr->flags = _flags_save_string;
10462                 }
10463                 {
10464                         uint32_t _flags_save_string = ndr->flags;
10465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10466                         if (r->help_file) {
10467                                 uint32_t _relative_save_offset;
10468                                 _relative_save_offset = ndr->offset;
10469                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10470                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10471                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10472                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10473                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10474                                 ndr->offset = _relative_save_offset;
10475                         }
10476                         ndr->flags = _flags_save_string;
10477                 }
10478                 {
10479                         uint32_t _flags_save_string_array = ndr->flags;
10480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10481                         if (r->dependent_files) {
10482                                 uint32_t _relative_save_offset;
10483                                 _relative_save_offset = ndr->offset;
10484                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10485                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10486                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10487                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10488                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10489                                 ndr->offset = _relative_save_offset;
10490                         }
10491                         ndr->flags = _flags_save_string_array;
10492                 }
10493                 {
10494                         uint32_t _flags_save_string = ndr->flags;
10495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10496                         if (r->monitor_name) {
10497                                 uint32_t _relative_save_offset;
10498                                 _relative_save_offset = ndr->offset;
10499                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10500                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10501                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10502                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10503                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10504                                 ndr->offset = _relative_save_offset;
10505                         }
10506                         ndr->flags = _flags_save_string;
10507                 }
10508                 {
10509                         uint32_t _flags_save_string = ndr->flags;
10510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10511                         if (r->default_datatype) {
10512                                 uint32_t _relative_save_offset;
10513                                 _relative_save_offset = ndr->offset;
10514                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10515                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10516                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10517                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10518                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10519                                 ndr->offset = _relative_save_offset;
10520                         }
10521                         ndr->flags = _flags_save_string;
10522                 }
10523         }
10524         return NDR_ERR_SUCCESS;
10525 }
10526
10527 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10528 {
10529         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10530         ndr->depth++;
10531         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10532         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10533         ndr->depth++;
10534         if (r->driver_name) {
10535                 ndr_print_string(ndr, "driver_name", r->driver_name);
10536         }
10537         ndr->depth--;
10538         ndr_print_ptr(ndr, "architecture", r->architecture);
10539         ndr->depth++;
10540         if (r->architecture) {
10541                 ndr_print_string(ndr, "architecture", r->architecture);
10542         }
10543         ndr->depth--;
10544         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10545         ndr->depth++;
10546         if (r->driver_path) {
10547                 ndr_print_string(ndr, "driver_path", r->driver_path);
10548         }
10549         ndr->depth--;
10550         ndr_print_ptr(ndr, "data_file", r->data_file);
10551         ndr->depth++;
10552         if (r->data_file) {
10553                 ndr_print_string(ndr, "data_file", r->data_file);
10554         }
10555         ndr->depth--;
10556         ndr_print_ptr(ndr, "config_file", r->config_file);
10557         ndr->depth++;
10558         if (r->config_file) {
10559                 ndr_print_string(ndr, "config_file", r->config_file);
10560         }
10561         ndr->depth--;
10562         ndr_print_ptr(ndr, "help_file", r->help_file);
10563         ndr->depth++;
10564         if (r->help_file) {
10565                 ndr_print_string(ndr, "help_file", r->help_file);
10566         }
10567         ndr->depth--;
10568         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10569         ndr->depth++;
10570         if (r->dependent_files) {
10571                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10572         }
10573         ndr->depth--;
10574         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10575         ndr->depth++;
10576         if (r->monitor_name) {
10577                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10578         }
10579         ndr->depth--;
10580         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10581         ndr->depth++;
10582         if (r->default_datatype) {
10583                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10584         }
10585         ndr->depth--;
10586         ndr->depth--;
10587 }
10588
10589 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10590 {
10591         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10592 }
10593
10594 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10595 {
10596         if (ndr_flags & NDR_SCALARS) {
10597                 NDR_CHECK(ndr_push_align(ndr, 4));
10598                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10599                 {
10600                         uint32_t _flags_save_string = ndr->flags;
10601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10602                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10603                         ndr->flags = _flags_save_string;
10604                 }
10605                 {
10606                         uint32_t _flags_save_string = ndr->flags;
10607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10608                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10609                         ndr->flags = _flags_save_string;
10610                 }
10611                 {
10612                         uint32_t _flags_save_string = ndr->flags;
10613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10615                         ndr->flags = _flags_save_string;
10616                 }
10617                 {
10618                         uint32_t _flags_save_string = ndr->flags;
10619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10620                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10621                         ndr->flags = _flags_save_string;
10622                 }
10623                 {
10624                         uint32_t _flags_save_string = ndr->flags;
10625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10626                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10627                         ndr->flags = _flags_save_string;
10628                 }
10629                 {
10630                         uint32_t _flags_save_string = ndr->flags;
10631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10632                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10633                         ndr->flags = _flags_save_string;
10634                 }
10635                 {
10636                         uint32_t _flags_save_string_array = ndr->flags;
10637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10638                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10639                         ndr->flags = _flags_save_string_array;
10640                 }
10641                 {
10642                         uint32_t _flags_save_string = ndr->flags;
10643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10645                         ndr->flags = _flags_save_string;
10646                 }
10647                 {
10648                         uint32_t _flags_save_string = ndr->flags;
10649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10650                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10651                         ndr->flags = _flags_save_string;
10652                 }
10653                 {
10654                         uint32_t _flags_save_string_array = ndr->flags;
10655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10656                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10657                         ndr->flags = _flags_save_string_array;
10658                 }
10659         }
10660         if (ndr_flags & NDR_BUFFERS) {
10661                 {
10662                         uint32_t _flags_save_string = ndr->flags;
10663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10664                         if (r->driver_name) {
10665                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10666                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10667                         }
10668                         ndr->flags = _flags_save_string;
10669                 }
10670                 {
10671                         uint32_t _flags_save_string = ndr->flags;
10672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10673                         if (r->architecture) {
10674                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10675                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10676                         }
10677                         ndr->flags = _flags_save_string;
10678                 }
10679                 {
10680                         uint32_t _flags_save_string = ndr->flags;
10681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10682                         if (r->driver_path) {
10683                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10684                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10685                         }
10686                         ndr->flags = _flags_save_string;
10687                 }
10688                 {
10689                         uint32_t _flags_save_string = ndr->flags;
10690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10691                         if (r->data_file) {
10692                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10693                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10694                         }
10695                         ndr->flags = _flags_save_string;
10696                 }
10697                 {
10698                         uint32_t _flags_save_string = ndr->flags;
10699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10700                         if (r->config_file) {
10701                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10702                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10703                         }
10704                         ndr->flags = _flags_save_string;
10705                 }
10706                 {
10707                         uint32_t _flags_save_string = ndr->flags;
10708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10709                         if (r->help_file) {
10710                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10711                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10712                         }
10713                         ndr->flags = _flags_save_string;
10714                 }
10715                 {
10716                         uint32_t _flags_save_string_array = ndr->flags;
10717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10718                         if (r->dependent_files) {
10719                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10720                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10721                         }
10722                         ndr->flags = _flags_save_string_array;
10723                 }
10724                 {
10725                         uint32_t _flags_save_string = ndr->flags;
10726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10727                         if (r->monitor_name) {
10728                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10729                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10730                         }
10731                         ndr->flags = _flags_save_string;
10732                 }
10733                 {
10734                         uint32_t _flags_save_string = ndr->flags;
10735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10736                         if (r->default_datatype) {
10737                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10738                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10739                         }
10740                         ndr->flags = _flags_save_string;
10741                 }
10742                 {
10743                         uint32_t _flags_save_string_array = ndr->flags;
10744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10745                         if (r->previous_names) {
10746                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10747                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10748                         }
10749                         ndr->flags = _flags_save_string_array;
10750                 }
10751         }
10752         return NDR_ERR_SUCCESS;
10753 }
10754
10755 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10756 {
10757         uint32_t _ptr_driver_name;
10758         TALLOC_CTX *_mem_save_driver_name_0;
10759         uint32_t _ptr_architecture;
10760         TALLOC_CTX *_mem_save_architecture_0;
10761         uint32_t _ptr_driver_path;
10762         TALLOC_CTX *_mem_save_driver_path_0;
10763         uint32_t _ptr_data_file;
10764         TALLOC_CTX *_mem_save_data_file_0;
10765         uint32_t _ptr_config_file;
10766         TALLOC_CTX *_mem_save_config_file_0;
10767         uint32_t _ptr_help_file;
10768         TALLOC_CTX *_mem_save_help_file_0;
10769         uint32_t _ptr_dependent_files;
10770         TALLOC_CTX *_mem_save_dependent_files_0;
10771         uint32_t _ptr_monitor_name;
10772         TALLOC_CTX *_mem_save_monitor_name_0;
10773         uint32_t _ptr_default_datatype;
10774         TALLOC_CTX *_mem_save_default_datatype_0;
10775         uint32_t _ptr_previous_names;
10776         TALLOC_CTX *_mem_save_previous_names_0;
10777         if (ndr_flags & NDR_SCALARS) {
10778                 NDR_CHECK(ndr_pull_align(ndr, 4));
10779                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10780                 {
10781                         uint32_t _flags_save_string = ndr->flags;
10782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10783                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10784                         if (_ptr_driver_name) {
10785                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10786                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10787                         } else {
10788                                 r->driver_name = NULL;
10789                         }
10790                         ndr->flags = _flags_save_string;
10791                 }
10792                 {
10793                         uint32_t _flags_save_string = ndr->flags;
10794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10795                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10796                         if (_ptr_architecture) {
10797                                 NDR_PULL_ALLOC(ndr, r->architecture);
10798                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10799                         } else {
10800                                 r->architecture = NULL;
10801                         }
10802                         ndr->flags = _flags_save_string;
10803                 }
10804                 {
10805                         uint32_t _flags_save_string = ndr->flags;
10806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10808                         if (_ptr_driver_path) {
10809                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10811                         } else {
10812                                 r->driver_path = NULL;
10813                         }
10814                         ndr->flags = _flags_save_string;
10815                 }
10816                 {
10817                         uint32_t _flags_save_string = ndr->flags;
10818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10820                         if (_ptr_data_file) {
10821                                 NDR_PULL_ALLOC(ndr, r->data_file);
10822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10823                         } else {
10824                                 r->data_file = NULL;
10825                         }
10826                         ndr->flags = _flags_save_string;
10827                 }
10828                 {
10829                         uint32_t _flags_save_string = ndr->flags;
10830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10832                         if (_ptr_config_file) {
10833                                 NDR_PULL_ALLOC(ndr, r->config_file);
10834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10835                         } else {
10836                                 r->config_file = NULL;
10837                         }
10838                         ndr->flags = _flags_save_string;
10839                 }
10840                 {
10841                         uint32_t _flags_save_string = ndr->flags;
10842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10844                         if (_ptr_help_file) {
10845                                 NDR_PULL_ALLOC(ndr, r->help_file);
10846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10847                         } else {
10848                                 r->help_file = NULL;
10849                         }
10850                         ndr->flags = _flags_save_string;
10851                 }
10852                 {
10853                         uint32_t _flags_save_string_array = ndr->flags;
10854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10856                         if (_ptr_dependent_files) {
10857                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10859                         } else {
10860                                 r->dependent_files = NULL;
10861                         }
10862                         ndr->flags = _flags_save_string_array;
10863                 }
10864                 {
10865                         uint32_t _flags_save_string = ndr->flags;
10866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10867                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10868                         if (_ptr_monitor_name) {
10869                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10870                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10871                         } else {
10872                                 r->monitor_name = NULL;
10873                         }
10874                         ndr->flags = _flags_save_string;
10875                 }
10876                 {
10877                         uint32_t _flags_save_string = ndr->flags;
10878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10879                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10880                         if (_ptr_default_datatype) {
10881                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10882                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10883                         } else {
10884                                 r->default_datatype = NULL;
10885                         }
10886                         ndr->flags = _flags_save_string;
10887                 }
10888                 {
10889                         uint32_t _flags_save_string_array = ndr->flags;
10890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10891                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10892                         if (_ptr_previous_names) {
10893                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10894                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10895                         } else {
10896                                 r->previous_names = NULL;
10897                         }
10898                         ndr->flags = _flags_save_string_array;
10899                 }
10900         }
10901         if (ndr_flags & NDR_BUFFERS) {
10902                 {
10903                         uint32_t _flags_save_string = ndr->flags;
10904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10905                         if (r->driver_name) {
10906                                 uint32_t _relative_save_offset;
10907                                 _relative_save_offset = ndr->offset;
10908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10909                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10910                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10913                                 ndr->offset = _relative_save_offset;
10914                         }
10915                         ndr->flags = _flags_save_string;
10916                 }
10917                 {
10918                         uint32_t _flags_save_string = ndr->flags;
10919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10920                         if (r->architecture) {
10921                                 uint32_t _relative_save_offset;
10922                                 _relative_save_offset = ndr->offset;
10923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10924                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10925                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10928                                 ndr->offset = _relative_save_offset;
10929                         }
10930                         ndr->flags = _flags_save_string;
10931                 }
10932                 {
10933                         uint32_t _flags_save_string = ndr->flags;
10934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10935                         if (r->driver_path) {
10936                                 uint32_t _relative_save_offset;
10937                                 _relative_save_offset = ndr->offset;
10938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10939                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10940                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10943                                 ndr->offset = _relative_save_offset;
10944                         }
10945                         ndr->flags = _flags_save_string;
10946                 }
10947                 {
10948                         uint32_t _flags_save_string = ndr->flags;
10949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10950                         if (r->data_file) {
10951                                 uint32_t _relative_save_offset;
10952                                 _relative_save_offset = ndr->offset;
10953                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10954                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10955                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10956                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10957                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10958                                 ndr->offset = _relative_save_offset;
10959                         }
10960                         ndr->flags = _flags_save_string;
10961                 }
10962                 {
10963                         uint32_t _flags_save_string = ndr->flags;
10964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10965                         if (r->config_file) {
10966                                 uint32_t _relative_save_offset;
10967                                 _relative_save_offset = ndr->offset;
10968                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10969                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10970                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10971                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10972                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10973                                 ndr->offset = _relative_save_offset;
10974                         }
10975                         ndr->flags = _flags_save_string;
10976                 }
10977                 {
10978                         uint32_t _flags_save_string = ndr->flags;
10979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10980                         if (r->help_file) {
10981                                 uint32_t _relative_save_offset;
10982                                 _relative_save_offset = ndr->offset;
10983                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10984                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10985                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10986                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10987                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10988                                 ndr->offset = _relative_save_offset;
10989                         }
10990                         ndr->flags = _flags_save_string;
10991                 }
10992                 {
10993                         uint32_t _flags_save_string_array = ndr->flags;
10994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10995                         if (r->dependent_files) {
10996                                 uint32_t _relative_save_offset;
10997                                 _relative_save_offset = ndr->offset;
10998                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10999                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11000                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11001                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11002                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11003                                 ndr->offset = _relative_save_offset;
11004                         }
11005                         ndr->flags = _flags_save_string_array;
11006                 }
11007                 {
11008                         uint32_t _flags_save_string = ndr->flags;
11009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11010                         if (r->monitor_name) {
11011                                 uint32_t _relative_save_offset;
11012                                 _relative_save_offset = ndr->offset;
11013                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11014                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11015                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11016                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11017                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11018                                 ndr->offset = _relative_save_offset;
11019                         }
11020                         ndr->flags = _flags_save_string;
11021                 }
11022                 {
11023                         uint32_t _flags_save_string = ndr->flags;
11024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11025                         if (r->default_datatype) {
11026                                 uint32_t _relative_save_offset;
11027                                 _relative_save_offset = ndr->offset;
11028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11029                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11030                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11033                                 ndr->offset = _relative_save_offset;
11034                         }
11035                         ndr->flags = _flags_save_string;
11036                 }
11037                 {
11038                         uint32_t _flags_save_string_array = ndr->flags;
11039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11040                         if (r->previous_names) {
11041                                 uint32_t _relative_save_offset;
11042                                 _relative_save_offset = ndr->offset;
11043                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11044                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11045                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11046                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11047                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11048                                 ndr->offset = _relative_save_offset;
11049                         }
11050                         ndr->flags = _flags_save_string_array;
11051                 }
11052         }
11053         return NDR_ERR_SUCCESS;
11054 }
11055
11056 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11057 {
11058         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11059         ndr->depth++;
11060         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11061         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11062         ndr->depth++;
11063         if (r->driver_name) {
11064                 ndr_print_string(ndr, "driver_name", r->driver_name);
11065         }
11066         ndr->depth--;
11067         ndr_print_ptr(ndr, "architecture", r->architecture);
11068         ndr->depth++;
11069         if (r->architecture) {
11070                 ndr_print_string(ndr, "architecture", r->architecture);
11071         }
11072         ndr->depth--;
11073         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11074         ndr->depth++;
11075         if (r->driver_path) {
11076                 ndr_print_string(ndr, "driver_path", r->driver_path);
11077         }
11078         ndr->depth--;
11079         ndr_print_ptr(ndr, "data_file", r->data_file);
11080         ndr->depth++;
11081         if (r->data_file) {
11082                 ndr_print_string(ndr, "data_file", r->data_file);
11083         }
11084         ndr->depth--;
11085         ndr_print_ptr(ndr, "config_file", r->config_file);
11086         ndr->depth++;
11087         if (r->config_file) {
11088                 ndr_print_string(ndr, "config_file", r->config_file);
11089         }
11090         ndr->depth--;
11091         ndr_print_ptr(ndr, "help_file", r->help_file);
11092         ndr->depth++;
11093         if (r->help_file) {
11094                 ndr_print_string(ndr, "help_file", r->help_file);
11095         }
11096         ndr->depth--;
11097         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11098         ndr->depth++;
11099         if (r->dependent_files) {
11100                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11101         }
11102         ndr->depth--;
11103         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11104         ndr->depth++;
11105         if (r->monitor_name) {
11106                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11107         }
11108         ndr->depth--;
11109         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11110         ndr->depth++;
11111         if (r->default_datatype) {
11112                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11113         }
11114         ndr->depth--;
11115         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11116         ndr->depth++;
11117         if (r->previous_names) {
11118                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11119         }
11120         ndr->depth--;
11121         ndr->depth--;
11122 }
11123
11124 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11125 {
11126         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11127 }
11128
11129 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11130 {
11131         if (ndr_flags & NDR_SCALARS) {
11132                 NDR_CHECK(ndr_push_align(ndr, 4));
11133                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11134                 {
11135                         uint32_t _flags_save_string = ndr->flags;
11136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11137                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11138                         ndr->flags = _flags_save_string;
11139                 }
11140                 {
11141                         uint32_t _flags_save_string = ndr->flags;
11142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11143                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11144                         ndr->flags = _flags_save_string;
11145                 }
11146                 {
11147                         uint32_t _flags_save_string = ndr->flags;
11148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11149                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11150                         ndr->flags = _flags_save_string;
11151                 }
11152                 {
11153                         uint32_t _flags_save_string = ndr->flags;
11154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11155                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11156                         ndr->flags = _flags_save_string;
11157                 }
11158                 {
11159                         uint32_t _flags_save_string = ndr->flags;
11160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11161                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11162                         ndr->flags = _flags_save_string;
11163                 }
11164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11167         }
11168         if (ndr_flags & NDR_BUFFERS) {
11169                 {
11170                         uint32_t _flags_save_string = ndr->flags;
11171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11172                         if (r->driver_name) {
11173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11175                         }
11176                         ndr->flags = _flags_save_string;
11177                 }
11178                 {
11179                         uint32_t _flags_save_string = ndr->flags;
11180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11181                         if (r->architecture) {
11182                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11183                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11184                         }
11185                         ndr->flags = _flags_save_string;
11186                 }
11187                 {
11188                         uint32_t _flags_save_string = ndr->flags;
11189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11190                         if (r->driver_path) {
11191                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11192                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11193                         }
11194                         ndr->flags = _flags_save_string;
11195                 }
11196                 {
11197                         uint32_t _flags_save_string = ndr->flags;
11198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11199                         if (r->data_file) {
11200                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11201                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11202                         }
11203                         ndr->flags = _flags_save_string;
11204                 }
11205                 {
11206                         uint32_t _flags_save_string = ndr->flags;
11207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11208                         if (r->config_file) {
11209                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11210                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11211                         }
11212                         ndr->flags = _flags_save_string;
11213                 }
11214         }
11215         return NDR_ERR_SUCCESS;
11216 }
11217
11218 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11219 {
11220         uint32_t _ptr_driver_name;
11221         TALLOC_CTX *_mem_save_driver_name_0;
11222         uint32_t _ptr_architecture;
11223         TALLOC_CTX *_mem_save_architecture_0;
11224         uint32_t _ptr_driver_path;
11225         TALLOC_CTX *_mem_save_driver_path_0;
11226         uint32_t _ptr_data_file;
11227         TALLOC_CTX *_mem_save_data_file_0;
11228         uint32_t _ptr_config_file;
11229         TALLOC_CTX *_mem_save_config_file_0;
11230         if (ndr_flags & NDR_SCALARS) {
11231                 NDR_CHECK(ndr_pull_align(ndr, 4));
11232                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11233                 {
11234                         uint32_t _flags_save_string = ndr->flags;
11235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11237                         if (_ptr_driver_name) {
11238                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11240                         } else {
11241                                 r->driver_name = NULL;
11242                         }
11243                         ndr->flags = _flags_save_string;
11244                 }
11245                 {
11246                         uint32_t _flags_save_string = ndr->flags;
11247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11249                         if (_ptr_architecture) {
11250                                 NDR_PULL_ALLOC(ndr, r->architecture);
11251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11252                         } else {
11253                                 r->architecture = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11261                         if (_ptr_driver_path) {
11262                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11264                         } else {
11265                                 r->driver_path = NULL;
11266                         }
11267                         ndr->flags = _flags_save_string;
11268                 }
11269                 {
11270                         uint32_t _flags_save_string = ndr->flags;
11271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11273                         if (_ptr_data_file) {
11274                                 NDR_PULL_ALLOC(ndr, r->data_file);
11275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11276                         } else {
11277                                 r->data_file = NULL;
11278                         }
11279                         ndr->flags = _flags_save_string;
11280                 }
11281                 {
11282                         uint32_t _flags_save_string = ndr->flags;
11283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11285                         if (_ptr_config_file) {
11286                                 NDR_PULL_ALLOC(ndr, r->config_file);
11287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11288                         } else {
11289                                 r->config_file = NULL;
11290                         }
11291                         ndr->flags = _flags_save_string;
11292                 }
11293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11296         }
11297         if (ndr_flags & NDR_BUFFERS) {
11298                 {
11299                         uint32_t _flags_save_string = ndr->flags;
11300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11301                         if (r->driver_name) {
11302                                 uint32_t _relative_save_offset;
11303                                 _relative_save_offset = ndr->offset;
11304                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11305                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11306                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11307                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11308                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11309                                 ndr->offset = _relative_save_offset;
11310                         }
11311                         ndr->flags = _flags_save_string;
11312                 }
11313                 {
11314                         uint32_t _flags_save_string = ndr->flags;
11315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11316                         if (r->architecture) {
11317                                 uint32_t _relative_save_offset;
11318                                 _relative_save_offset = ndr->offset;
11319                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11320                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11321                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11322                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11323                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11324                                 ndr->offset = _relative_save_offset;
11325                         }
11326                         ndr->flags = _flags_save_string;
11327                 }
11328                 {
11329                         uint32_t _flags_save_string = ndr->flags;
11330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11331                         if (r->driver_path) {
11332                                 uint32_t _relative_save_offset;
11333                                 _relative_save_offset = ndr->offset;
11334                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11335                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11336                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11337                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11338                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11339                                 ndr->offset = _relative_save_offset;
11340                         }
11341                         ndr->flags = _flags_save_string;
11342                 }
11343                 {
11344                         uint32_t _flags_save_string = ndr->flags;
11345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11346                         if (r->data_file) {
11347                                 uint32_t _relative_save_offset;
11348                                 _relative_save_offset = ndr->offset;
11349                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11350                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11351                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11352                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11353                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11354                                 ndr->offset = _relative_save_offset;
11355                         }
11356                         ndr->flags = _flags_save_string;
11357                 }
11358                 {
11359                         uint32_t _flags_save_string = ndr->flags;
11360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11361                         if (r->config_file) {
11362                                 uint32_t _relative_save_offset;
11363                                 _relative_save_offset = ndr->offset;
11364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11365                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11366                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11369                                 ndr->offset = _relative_save_offset;
11370                         }
11371                         ndr->flags = _flags_save_string;
11372                 }
11373         }
11374         return NDR_ERR_SUCCESS;
11375 }
11376
11377 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11378 {
11379         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11380         ndr->depth++;
11381         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11382         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11383         ndr->depth++;
11384         if (r->driver_name) {
11385                 ndr_print_string(ndr, "driver_name", r->driver_name);
11386         }
11387         ndr->depth--;
11388         ndr_print_ptr(ndr, "architecture", r->architecture);
11389         ndr->depth++;
11390         if (r->architecture) {
11391                 ndr_print_string(ndr, "architecture", r->architecture);
11392         }
11393         ndr->depth--;
11394         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11395         ndr->depth++;
11396         if (r->driver_path) {
11397                 ndr_print_string(ndr, "driver_path", r->driver_path);
11398         }
11399         ndr->depth--;
11400         ndr_print_ptr(ndr, "data_file", r->data_file);
11401         ndr->depth++;
11402         if (r->data_file) {
11403                 ndr_print_string(ndr, "data_file", r->data_file);
11404         }
11405         ndr->depth--;
11406         ndr_print_ptr(ndr, "config_file", r->config_file);
11407         ndr->depth++;
11408         if (r->config_file) {
11409                 ndr_print_string(ndr, "config_file", r->config_file);
11410         }
11411         ndr->depth--;
11412         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11413         ndr_print_uint32(ndr, "config_version", r->config_version);
11414         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11415         ndr->depth--;
11416 }
11417
11418 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11419 {
11420         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11421 }
11422
11423 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11424 {
11425         if (ndr_flags & NDR_SCALARS) {
11426                 NDR_CHECK(ndr_push_align(ndr, 8));
11427                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11428                 {
11429                         uint32_t _flags_save_string = ndr->flags;
11430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11431                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11432                         ndr->flags = _flags_save_string;
11433                 }
11434                 {
11435                         uint32_t _flags_save_string = ndr->flags;
11436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11437                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11438                         ndr->flags = _flags_save_string;
11439                 }
11440                 {
11441                         uint32_t _flags_save_string = ndr->flags;
11442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11443                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11444                         ndr->flags = _flags_save_string;
11445                 }
11446                 {
11447                         uint32_t _flags_save_string = ndr->flags;
11448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11449                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11450                         ndr->flags = _flags_save_string;
11451                 }
11452                 {
11453                         uint32_t _flags_save_string = ndr->flags;
11454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11455                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11456                         ndr->flags = _flags_save_string;
11457                 }
11458                 {
11459                         uint32_t _flags_save_string = ndr->flags;
11460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11461                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11462                         ndr->flags = _flags_save_string;
11463                 }
11464                 {
11465                         uint32_t _flags_save_string_array = ndr->flags;
11466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11468                         ndr->flags = _flags_save_string_array;
11469                 }
11470                 {
11471                         uint32_t _flags_save_string = ndr->flags;
11472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11474                         ndr->flags = _flags_save_string;
11475                 }
11476                 {
11477                         uint32_t _flags_save_string = ndr->flags;
11478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11480                         ndr->flags = _flags_save_string;
11481                 }
11482                 {
11483                         uint32_t _flags_save_string_array = ndr->flags;
11484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11485                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11486                         ndr->flags = _flags_save_string_array;
11487                 }
11488                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11489                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11490                 {
11491                         uint32_t _flags_save_string = ndr->flags;
11492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11493                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11494                         ndr->flags = _flags_save_string;
11495                 }
11496                 {
11497                         uint32_t _flags_save_string = ndr->flags;
11498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11499                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11500                         ndr->flags = _flags_save_string;
11501                 }
11502                 {
11503                         uint32_t _flags_save_string = ndr->flags;
11504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11505                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11506                         ndr->flags = _flags_save_string;
11507                 }
11508                 {
11509                         uint32_t _flags_save_string = ndr->flags;
11510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11511                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11512                         ndr->flags = _flags_save_string;
11513                 }
11514         }
11515         if (ndr_flags & NDR_BUFFERS) {
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         if (r->driver_name) {
11520                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11521                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11522                         }
11523                         ndr->flags = _flags_save_string;
11524                 }
11525                 {
11526                         uint32_t _flags_save_string = ndr->flags;
11527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11528                         if (r->architecture) {
11529                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11530                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11531                         }
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         if (r->driver_path) {
11538                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11539                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11540                         }
11541                         ndr->flags = _flags_save_string;
11542                 }
11543                 {
11544                         uint32_t _flags_save_string = ndr->flags;
11545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11546                         if (r->data_file) {
11547                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11548                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11549                         }
11550                         ndr->flags = _flags_save_string;
11551                 }
11552                 {
11553                         uint32_t _flags_save_string = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         if (r->config_file) {
11556                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11558                         }
11559                         ndr->flags = _flags_save_string;
11560                 }
11561                 {
11562                         uint32_t _flags_save_string = ndr->flags;
11563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11564                         if (r->help_file) {
11565                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11566                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11567                         }
11568                         ndr->flags = _flags_save_string;
11569                 }
11570                 {
11571                         uint32_t _flags_save_string_array = ndr->flags;
11572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11573                         if (r->dependent_files) {
11574                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11575                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11576                         }
11577                         ndr->flags = _flags_save_string_array;
11578                 }
11579                 {
11580                         uint32_t _flags_save_string = ndr->flags;
11581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11582                         if (r->monitor_name) {
11583                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11584                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11585                         }
11586                         ndr->flags = _flags_save_string;
11587                 }
11588                 {
11589                         uint32_t _flags_save_string = ndr->flags;
11590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11591                         if (r->default_datatype) {
11592                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11593                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11594                         }
11595                         ndr->flags = _flags_save_string;
11596                 }
11597                 {
11598                         uint32_t _flags_save_string_array = ndr->flags;
11599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11600                         if (r->previous_names) {
11601                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11602                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11603                         }
11604                         ndr->flags = _flags_save_string_array;
11605                 }
11606                 {
11607                         uint32_t _flags_save_string = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         if (r->manufacturer_name) {
11610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11612                         }
11613                         ndr->flags = _flags_save_string;
11614                 }
11615                 {
11616                         uint32_t _flags_save_string = ndr->flags;
11617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11618                         if (r->manufacturer_url) {
11619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11621                         }
11622                         ndr->flags = _flags_save_string;
11623                 }
11624                 {
11625                         uint32_t _flags_save_string = ndr->flags;
11626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11627                         if (r->hardware_id) {
11628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11630                         }
11631                         ndr->flags = _flags_save_string;
11632                 }
11633                 {
11634                         uint32_t _flags_save_string = ndr->flags;
11635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11636                         if (r->provider) {
11637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11639                         }
11640                         ndr->flags = _flags_save_string;
11641                 }
11642         }
11643         return NDR_ERR_SUCCESS;
11644 }
11645
11646 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11647 {
11648         uint32_t _ptr_driver_name;
11649         TALLOC_CTX *_mem_save_driver_name_0;
11650         uint32_t _ptr_architecture;
11651         TALLOC_CTX *_mem_save_architecture_0;
11652         uint32_t _ptr_driver_path;
11653         TALLOC_CTX *_mem_save_driver_path_0;
11654         uint32_t _ptr_data_file;
11655         TALLOC_CTX *_mem_save_data_file_0;
11656         uint32_t _ptr_config_file;
11657         TALLOC_CTX *_mem_save_config_file_0;
11658         uint32_t _ptr_help_file;
11659         TALLOC_CTX *_mem_save_help_file_0;
11660         uint32_t _ptr_dependent_files;
11661         TALLOC_CTX *_mem_save_dependent_files_0;
11662         uint32_t _ptr_monitor_name;
11663         TALLOC_CTX *_mem_save_monitor_name_0;
11664         uint32_t _ptr_default_datatype;
11665         TALLOC_CTX *_mem_save_default_datatype_0;
11666         uint32_t _ptr_previous_names;
11667         TALLOC_CTX *_mem_save_previous_names_0;
11668         uint32_t _ptr_manufacturer_name;
11669         TALLOC_CTX *_mem_save_manufacturer_name_0;
11670         uint32_t _ptr_manufacturer_url;
11671         TALLOC_CTX *_mem_save_manufacturer_url_0;
11672         uint32_t _ptr_hardware_id;
11673         TALLOC_CTX *_mem_save_hardware_id_0;
11674         uint32_t _ptr_provider;
11675         TALLOC_CTX *_mem_save_provider_0;
11676         if (ndr_flags & NDR_SCALARS) {
11677                 NDR_CHECK(ndr_pull_align(ndr, 8));
11678                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11679                 {
11680                         uint32_t _flags_save_string = ndr->flags;
11681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11682                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11683                         if (_ptr_driver_name) {
11684                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11685                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11686                         } else {
11687                                 r->driver_name = NULL;
11688                         }
11689                         ndr->flags = _flags_save_string;
11690                 }
11691                 {
11692                         uint32_t _flags_save_string = ndr->flags;
11693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11695                         if (_ptr_architecture) {
11696                                 NDR_PULL_ALLOC(ndr, r->architecture);
11697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11698                         } else {
11699                                 r->architecture = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11707                         if (_ptr_driver_path) {
11708                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11709                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11710                         } else {
11711                                 r->driver_path = NULL;
11712                         }
11713                         ndr->flags = _flags_save_string;
11714                 }
11715                 {
11716                         uint32_t _flags_save_string = ndr->flags;
11717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11718                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11719                         if (_ptr_data_file) {
11720                                 NDR_PULL_ALLOC(ndr, r->data_file);
11721                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11722                         } else {
11723                                 r->data_file = NULL;
11724                         }
11725                         ndr->flags = _flags_save_string;
11726                 }
11727                 {
11728                         uint32_t _flags_save_string = ndr->flags;
11729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11731                         if (_ptr_config_file) {
11732                                 NDR_PULL_ALLOC(ndr, r->config_file);
11733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11734                         } else {
11735                                 r->config_file = NULL;
11736                         }
11737                         ndr->flags = _flags_save_string;
11738                 }
11739                 {
11740                         uint32_t _flags_save_string = ndr->flags;
11741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11742                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11743                         if (_ptr_help_file) {
11744                                 NDR_PULL_ALLOC(ndr, r->help_file);
11745                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11746                         } else {
11747                                 r->help_file = NULL;
11748                         }
11749                         ndr->flags = _flags_save_string;
11750                 }
11751                 {
11752                         uint32_t _flags_save_string_array = ndr->flags;
11753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11754                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11755                         if (_ptr_dependent_files) {
11756                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11757                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11758                         } else {
11759                                 r->dependent_files = NULL;
11760                         }
11761                         ndr->flags = _flags_save_string_array;
11762                 }
11763                 {
11764                         uint32_t _flags_save_string = ndr->flags;
11765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11766                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11767                         if (_ptr_monitor_name) {
11768                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11769                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11770                         } else {
11771                                 r->monitor_name = NULL;
11772                         }
11773                         ndr->flags = _flags_save_string;
11774                 }
11775                 {
11776                         uint32_t _flags_save_string = ndr->flags;
11777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11779                         if (_ptr_default_datatype) {
11780                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11782                         } else {
11783                                 r->default_datatype = NULL;
11784                         }
11785                         ndr->flags = _flags_save_string;
11786                 }
11787                 {
11788                         uint32_t _flags_save_string_array = ndr->flags;
11789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11791                         if (_ptr_previous_names) {
11792                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11794                         } else {
11795                                 r->previous_names = NULL;
11796                         }
11797                         ndr->flags = _flags_save_string_array;
11798                 }
11799                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11800                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11801                 {
11802                         uint32_t _flags_save_string = ndr->flags;
11803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11804                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11805                         if (_ptr_manufacturer_name) {
11806                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11807                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11808                         } else {
11809                                 r->manufacturer_name = NULL;
11810                         }
11811                         ndr->flags = _flags_save_string;
11812                 }
11813                 {
11814                         uint32_t _flags_save_string = ndr->flags;
11815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11816                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11817                         if (_ptr_manufacturer_url) {
11818                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11819                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11820                         } else {
11821                                 r->manufacturer_url = NULL;
11822                         }
11823                         ndr->flags = _flags_save_string;
11824                 }
11825                 {
11826                         uint32_t _flags_save_string = ndr->flags;
11827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11828                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11829                         if (_ptr_hardware_id) {
11830                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11831                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11832                         } else {
11833                                 r->hardware_id = NULL;
11834                         }
11835                         ndr->flags = _flags_save_string;
11836                 }
11837                 {
11838                         uint32_t _flags_save_string = ndr->flags;
11839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11841                         if (_ptr_provider) {
11842                                 NDR_PULL_ALLOC(ndr, r->provider);
11843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11844                         } else {
11845                                 r->provider = NULL;
11846                         }
11847                         ndr->flags = _flags_save_string;
11848                 }
11849         }
11850         if (ndr_flags & NDR_BUFFERS) {
11851                 {
11852                         uint32_t _flags_save_string = ndr->flags;
11853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11854                         if (r->driver_name) {
11855                                 uint32_t _relative_save_offset;
11856                                 _relative_save_offset = ndr->offset;
11857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11858                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11859                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11862                                 ndr->offset = _relative_save_offset;
11863                         }
11864                         ndr->flags = _flags_save_string;
11865                 }
11866                 {
11867                         uint32_t _flags_save_string = ndr->flags;
11868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11869                         if (r->architecture) {
11870                                 uint32_t _relative_save_offset;
11871                                 _relative_save_offset = ndr->offset;
11872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11873                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11874                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11877                                 ndr->offset = _relative_save_offset;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         if (r->driver_path) {
11885                                 uint32_t _relative_save_offset;
11886                                 _relative_save_offset = ndr->offset;
11887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11888                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11892                                 ndr->offset = _relative_save_offset;
11893                         }
11894                         ndr->flags = _flags_save_string;
11895                 }
11896                 {
11897                         uint32_t _flags_save_string = ndr->flags;
11898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11899                         if (r->data_file) {
11900                                 uint32_t _relative_save_offset;
11901                                 _relative_save_offset = ndr->offset;
11902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11903                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11904                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11907                                 ndr->offset = _relative_save_offset;
11908                         }
11909                         ndr->flags = _flags_save_string;
11910                 }
11911                 {
11912                         uint32_t _flags_save_string = ndr->flags;
11913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11914                         if (r->config_file) {
11915                                 uint32_t _relative_save_offset;
11916                                 _relative_save_offset = ndr->offset;
11917                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11918                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11919                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11920                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11921                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11922                                 ndr->offset = _relative_save_offset;
11923                         }
11924                         ndr->flags = _flags_save_string;
11925                 }
11926                 {
11927                         uint32_t _flags_save_string = ndr->flags;
11928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11929                         if (r->help_file) {
11930                                 uint32_t _relative_save_offset;
11931                                 _relative_save_offset = ndr->offset;
11932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11933                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11934                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11937                                 ndr->offset = _relative_save_offset;
11938                         }
11939                         ndr->flags = _flags_save_string;
11940                 }
11941                 {
11942                         uint32_t _flags_save_string_array = ndr->flags;
11943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11944                         if (r->dependent_files) {
11945                                 uint32_t _relative_save_offset;
11946                                 _relative_save_offset = ndr->offset;
11947                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11948                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11949                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11950                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11951                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11952                                 ndr->offset = _relative_save_offset;
11953                         }
11954                         ndr->flags = _flags_save_string_array;
11955                 }
11956                 {
11957                         uint32_t _flags_save_string = ndr->flags;
11958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11959                         if (r->monitor_name) {
11960                                 uint32_t _relative_save_offset;
11961                                 _relative_save_offset = ndr->offset;
11962                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11963                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11964                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11965                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11966                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11967                                 ndr->offset = _relative_save_offset;
11968                         }
11969                         ndr->flags = _flags_save_string;
11970                 }
11971                 {
11972                         uint32_t _flags_save_string = ndr->flags;
11973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11974                         if (r->default_datatype) {
11975                                 uint32_t _relative_save_offset;
11976                                 _relative_save_offset = ndr->offset;
11977                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11978                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11979                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11980                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11981                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11982                                 ndr->offset = _relative_save_offset;
11983                         }
11984                         ndr->flags = _flags_save_string;
11985                 }
11986                 {
11987                         uint32_t _flags_save_string_array = ndr->flags;
11988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11989                         if (r->previous_names) {
11990                                 uint32_t _relative_save_offset;
11991                                 _relative_save_offset = ndr->offset;
11992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11993                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11994                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11995                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11997                                 ndr->offset = _relative_save_offset;
11998                         }
11999                         ndr->flags = _flags_save_string_array;
12000                 }
12001                 {
12002                         uint32_t _flags_save_string = ndr->flags;
12003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12004                         if (r->manufacturer_name) {
12005                                 uint32_t _relative_save_offset;
12006                                 _relative_save_offset = ndr->offset;
12007                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12008                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12009                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12010                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12011                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12012                                 ndr->offset = _relative_save_offset;
12013                         }
12014                         ndr->flags = _flags_save_string;
12015                 }
12016                 {
12017                         uint32_t _flags_save_string = ndr->flags;
12018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12019                         if (r->manufacturer_url) {
12020                                 uint32_t _relative_save_offset;
12021                                 _relative_save_offset = ndr->offset;
12022                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12023                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12024                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12025                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12026                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12027                                 ndr->offset = _relative_save_offset;
12028                         }
12029                         ndr->flags = _flags_save_string;
12030                 }
12031                 {
12032                         uint32_t _flags_save_string = ndr->flags;
12033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12034                         if (r->hardware_id) {
12035                                 uint32_t _relative_save_offset;
12036                                 _relative_save_offset = ndr->offset;
12037                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12038                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12039                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12040                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12041                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12042                                 ndr->offset = _relative_save_offset;
12043                         }
12044                         ndr->flags = _flags_save_string;
12045                 }
12046                 {
12047                         uint32_t _flags_save_string = ndr->flags;
12048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12049                         if (r->provider) {
12050                                 uint32_t _relative_save_offset;
12051                                 _relative_save_offset = ndr->offset;
12052                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12053                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12054                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12055                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12056                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12057                                 ndr->offset = _relative_save_offset;
12058                         }
12059                         ndr->flags = _flags_save_string;
12060                 }
12061         }
12062         return NDR_ERR_SUCCESS;
12063 }
12064
12065 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12066 {
12067         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12068         ndr->depth++;
12069         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12070         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12071         ndr->depth++;
12072         if (r->driver_name) {
12073                 ndr_print_string(ndr, "driver_name", r->driver_name);
12074         }
12075         ndr->depth--;
12076         ndr_print_ptr(ndr, "architecture", r->architecture);
12077         ndr->depth++;
12078         if (r->architecture) {
12079                 ndr_print_string(ndr, "architecture", r->architecture);
12080         }
12081         ndr->depth--;
12082         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12083         ndr->depth++;
12084         if (r->driver_path) {
12085                 ndr_print_string(ndr, "driver_path", r->driver_path);
12086         }
12087         ndr->depth--;
12088         ndr_print_ptr(ndr, "data_file", r->data_file);
12089         ndr->depth++;
12090         if (r->data_file) {
12091                 ndr_print_string(ndr, "data_file", r->data_file);
12092         }
12093         ndr->depth--;
12094         ndr_print_ptr(ndr, "config_file", r->config_file);
12095         ndr->depth++;
12096         if (r->config_file) {
12097                 ndr_print_string(ndr, "config_file", r->config_file);
12098         }
12099         ndr->depth--;
12100         ndr_print_ptr(ndr, "help_file", r->help_file);
12101         ndr->depth++;
12102         if (r->help_file) {
12103                 ndr_print_string(ndr, "help_file", r->help_file);
12104         }
12105         ndr->depth--;
12106         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12107         ndr->depth++;
12108         if (r->dependent_files) {
12109                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12110         }
12111         ndr->depth--;
12112         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12113         ndr->depth++;
12114         if (r->monitor_name) {
12115                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12116         }
12117         ndr->depth--;
12118         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12119         ndr->depth++;
12120         if (r->default_datatype) {
12121                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12122         }
12123         ndr->depth--;
12124         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12125         ndr->depth++;
12126         if (r->previous_names) {
12127                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12128         }
12129         ndr->depth--;
12130         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12131         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12132         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12133         ndr->depth++;
12134         if (r->manufacturer_name) {
12135                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12136         }
12137         ndr->depth--;
12138         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12139         ndr->depth++;
12140         if (r->manufacturer_url) {
12141                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12142         }
12143         ndr->depth--;
12144         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12145         ndr->depth++;
12146         if (r->hardware_id) {
12147                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12148         }
12149         ndr->depth--;
12150         ndr_print_ptr(ndr, "provider", r->provider);
12151         ndr->depth++;
12152         if (r->provider) {
12153                 ndr_print_string(ndr, "provider", r->provider);
12154         }
12155         ndr->depth--;
12156         ndr->depth--;
12157 }
12158
12159 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12160 {
12161         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12162 }
12163
12164 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12165 {
12166         if (ndr_flags & NDR_SCALARS) {
12167                 NDR_CHECK(ndr_push_align(ndr, 8));
12168                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12169                 {
12170                         uint32_t _flags_save_string = ndr->flags;
12171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12172                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12173                         ndr->flags = _flags_save_string;
12174                 }
12175                 {
12176                         uint32_t _flags_save_string = ndr->flags;
12177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12178                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12179                         ndr->flags = _flags_save_string;
12180                 }
12181                 {
12182                         uint32_t _flags_save_string = ndr->flags;
12183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12184                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12185                         ndr->flags = _flags_save_string;
12186                 }
12187                 {
12188                         uint32_t _flags_save_string = ndr->flags;
12189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12190                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12191                         ndr->flags = _flags_save_string;
12192                 }
12193                 {
12194                         uint32_t _flags_save_string = ndr->flags;
12195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12196                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12197                         ndr->flags = _flags_save_string;
12198                 }
12199                 {
12200                         uint32_t _flags_save_string = ndr->flags;
12201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12202                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12203                         ndr->flags = _flags_save_string;
12204                 }
12205                 {
12206                         uint32_t _flags_save_string = ndr->flags;
12207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12208                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12209                         ndr->flags = _flags_save_string;
12210                 }
12211                 {
12212                         uint32_t _flags_save_string = ndr->flags;
12213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12214                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12215                         ndr->flags = _flags_save_string;
12216                 }
12217                 {
12218                         uint32_t _flags_save_string_array = ndr->flags;
12219                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12220                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12221                         ndr->flags = _flags_save_string_array;
12222                 }
12223                 {
12224                         uint32_t _flags_save_string_array = ndr->flags;
12225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12226                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12227                         ndr->flags = _flags_save_string_array;
12228                 }
12229                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12230                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12231                 {
12232                         uint32_t _flags_save_string = ndr->flags;
12233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12235                         ndr->flags = _flags_save_string;
12236                 }
12237                 {
12238                         uint32_t _flags_save_string = ndr->flags;
12239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12240                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12241                         ndr->flags = _flags_save_string;
12242                 }
12243                 {
12244                         uint32_t _flags_save_string = ndr->flags;
12245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12246                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12247                         ndr->flags = _flags_save_string;
12248                 }
12249                 {
12250                         uint32_t _flags_save_string = ndr->flags;
12251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12252                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12253                         ndr->flags = _flags_save_string;
12254                 }
12255                 {
12256                         uint32_t _flags_save_string = ndr->flags;
12257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12258                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12259                         ndr->flags = _flags_save_string;
12260                 }
12261                 {
12262                         uint32_t _flags_save_string = ndr->flags;
12263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12264                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12265                         ndr->flags = _flags_save_string;
12266                 }
12267                 {
12268                         uint32_t _flags_save_string_array = ndr->flags;
12269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12271                         ndr->flags = _flags_save_string_array;
12272                 }
12273                 {
12274                         uint32_t _flags_save_string = ndr->flags;
12275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12277                         ndr->flags = _flags_save_string;
12278                 }
12279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12280                 {
12281                         uint32_t _flags_save_string_array = ndr->flags;
12282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12283                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12284                         ndr->flags = _flags_save_string_array;
12285                 }
12286                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12287                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12288         }
12289         if (ndr_flags & NDR_BUFFERS) {
12290                 {
12291                         uint32_t _flags_save_string = ndr->flags;
12292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12293                         if (r->driver_name) {
12294                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12295                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12296                         }
12297                         ndr->flags = _flags_save_string;
12298                 }
12299                 {
12300                         uint32_t _flags_save_string = ndr->flags;
12301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12302                         if (r->architecture) {
12303                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12305                         }
12306                         ndr->flags = _flags_save_string;
12307                 }
12308                 {
12309                         uint32_t _flags_save_string = ndr->flags;
12310                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12311                         if (r->driver_path) {
12312                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12313                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12314                         }
12315                         ndr->flags = _flags_save_string;
12316                 }
12317                 {
12318                         uint32_t _flags_save_string = ndr->flags;
12319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12320                         if (r->data_file) {
12321                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12322                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12323                         }
12324                         ndr->flags = _flags_save_string;
12325                 }
12326                 {
12327                         uint32_t _flags_save_string = ndr->flags;
12328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12329                         if (r->config_file) {
12330                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12331                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12332                         }
12333                         ndr->flags = _flags_save_string;
12334                 }
12335                 {
12336                         uint32_t _flags_save_string = ndr->flags;
12337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12338                         if (r->help_file) {
12339                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12340                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12341                         }
12342                         ndr->flags = _flags_save_string;
12343                 }
12344                 {
12345                         uint32_t _flags_save_string = ndr->flags;
12346                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12347                         if (r->monitor_name) {
12348                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12349                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12350                         }
12351                         ndr->flags = _flags_save_string;
12352                 }
12353                 {
12354                         uint32_t _flags_save_string = ndr->flags;
12355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12356                         if (r->default_datatype) {
12357                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12358                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12359                         }
12360                         ndr->flags = _flags_save_string;
12361                 }
12362                 {
12363                         uint32_t _flags_save_string_array = ndr->flags;
12364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12365                         if (r->dependent_files) {
12366                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12367                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12368                         }
12369                         ndr->flags = _flags_save_string_array;
12370                 }
12371                 {
12372                         uint32_t _flags_save_string_array = ndr->flags;
12373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12374                         if (r->previous_names) {
12375                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12376                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12377                         }
12378                         ndr->flags = _flags_save_string_array;
12379                 }
12380                 {
12381                         uint32_t _flags_save_string = ndr->flags;
12382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12383                         if (r->manufacturer_name) {
12384                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12385                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12386                         }
12387                         ndr->flags = _flags_save_string;
12388                 }
12389                 {
12390                         uint32_t _flags_save_string = ndr->flags;
12391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12392                         if (r->manufacturer_url) {
12393                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12394                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12395                         }
12396                         ndr->flags = _flags_save_string;
12397                 }
12398                 {
12399                         uint32_t _flags_save_string = ndr->flags;
12400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12401                         if (r->hardware_id) {
12402                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12403                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12404                         }
12405                         ndr->flags = _flags_save_string;
12406                 }
12407                 {
12408                         uint32_t _flags_save_string = ndr->flags;
12409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12410                         if (r->provider) {
12411                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12412                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12413                         }
12414                         ndr->flags = _flags_save_string;
12415                 }
12416                 {
12417                         uint32_t _flags_save_string = ndr->flags;
12418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12419                         if (r->print_processor) {
12420                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12421                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12422                         }
12423                         ndr->flags = _flags_save_string;
12424                 }
12425                 {
12426                         uint32_t _flags_save_string = ndr->flags;
12427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12428                         if (r->vendor_setup) {
12429                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12430                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12431                         }
12432                         ndr->flags = _flags_save_string;
12433                 }
12434                 {
12435                         uint32_t _flags_save_string_array = ndr->flags;
12436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12437                         if (r->color_profiles) {
12438                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12439                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12440                         }
12441                         ndr->flags = _flags_save_string_array;
12442                 }
12443                 {
12444                         uint32_t _flags_save_string = ndr->flags;
12445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12446                         if (r->inf_path) {
12447                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12448                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12449                         }
12450                         ndr->flags = _flags_save_string;
12451                 }
12452                 {
12453                         uint32_t _flags_save_string_array = ndr->flags;
12454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12455                         if (r->core_driver_dependencies) {
12456                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12457                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12458                         }
12459                         ndr->flags = _flags_save_string_array;
12460                 }
12461         }
12462         return NDR_ERR_SUCCESS;
12463 }
12464
12465 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12466 {
12467         uint32_t _ptr_driver_name;
12468         TALLOC_CTX *_mem_save_driver_name_0;
12469         uint32_t _ptr_architecture;
12470         TALLOC_CTX *_mem_save_architecture_0;
12471         uint32_t _ptr_driver_path;
12472         TALLOC_CTX *_mem_save_driver_path_0;
12473         uint32_t _ptr_data_file;
12474         TALLOC_CTX *_mem_save_data_file_0;
12475         uint32_t _ptr_config_file;
12476         TALLOC_CTX *_mem_save_config_file_0;
12477         uint32_t _ptr_help_file;
12478         TALLOC_CTX *_mem_save_help_file_0;
12479         uint32_t _ptr_monitor_name;
12480         TALLOC_CTX *_mem_save_monitor_name_0;
12481         uint32_t _ptr_default_datatype;
12482         TALLOC_CTX *_mem_save_default_datatype_0;
12483         uint32_t _ptr_dependent_files;
12484         TALLOC_CTX *_mem_save_dependent_files_0;
12485         uint32_t _ptr_previous_names;
12486         TALLOC_CTX *_mem_save_previous_names_0;
12487         uint32_t _ptr_manufacturer_name;
12488         TALLOC_CTX *_mem_save_manufacturer_name_0;
12489         uint32_t _ptr_manufacturer_url;
12490         TALLOC_CTX *_mem_save_manufacturer_url_0;
12491         uint32_t _ptr_hardware_id;
12492         TALLOC_CTX *_mem_save_hardware_id_0;
12493         uint32_t _ptr_provider;
12494         TALLOC_CTX *_mem_save_provider_0;
12495         uint32_t _ptr_print_processor;
12496         TALLOC_CTX *_mem_save_print_processor_0;
12497         uint32_t _ptr_vendor_setup;
12498         TALLOC_CTX *_mem_save_vendor_setup_0;
12499         uint32_t _ptr_color_profiles;
12500         TALLOC_CTX *_mem_save_color_profiles_0;
12501         uint32_t _ptr_inf_path;
12502         TALLOC_CTX *_mem_save_inf_path_0;
12503         uint32_t _ptr_core_driver_dependencies;
12504         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12505         if (ndr_flags & NDR_SCALARS) {
12506                 NDR_CHECK(ndr_pull_align(ndr, 8));
12507                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12508                 {
12509                         uint32_t _flags_save_string = ndr->flags;
12510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12511                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12512                         if (_ptr_driver_name) {
12513                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12514                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12515                         } else {
12516                                 r->driver_name = NULL;
12517                         }
12518                         ndr->flags = _flags_save_string;
12519                 }
12520                 {
12521                         uint32_t _flags_save_string = ndr->flags;
12522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12524                         if (_ptr_architecture) {
12525                                 NDR_PULL_ALLOC(ndr, r->architecture);
12526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12527                         } else {
12528                                 r->architecture = NULL;
12529                         }
12530                         ndr->flags = _flags_save_string;
12531                 }
12532                 {
12533                         uint32_t _flags_save_string = ndr->flags;
12534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12535                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12536                         if (_ptr_driver_path) {
12537                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12538                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12539                         } else {
12540                                 r->driver_path = NULL;
12541                         }
12542                         ndr->flags = _flags_save_string;
12543                 }
12544                 {
12545                         uint32_t _flags_save_string = ndr->flags;
12546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12547                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12548                         if (_ptr_data_file) {
12549                                 NDR_PULL_ALLOC(ndr, r->data_file);
12550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12551                         } else {
12552                                 r->data_file = NULL;
12553                         }
12554                         ndr->flags = _flags_save_string;
12555                 }
12556                 {
12557                         uint32_t _flags_save_string = ndr->flags;
12558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12560                         if (_ptr_config_file) {
12561                                 NDR_PULL_ALLOC(ndr, r->config_file);
12562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12563                         } else {
12564                                 r->config_file = NULL;
12565                         }
12566                         ndr->flags = _flags_save_string;
12567                 }
12568                 {
12569                         uint32_t _flags_save_string = ndr->flags;
12570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12572                         if (_ptr_help_file) {
12573                                 NDR_PULL_ALLOC(ndr, r->help_file);
12574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12575                         } else {
12576                                 r->help_file = NULL;
12577                         }
12578                         ndr->flags = _flags_save_string;
12579                 }
12580                 {
12581                         uint32_t _flags_save_string = ndr->flags;
12582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12583                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12584                         if (_ptr_monitor_name) {
12585                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12586                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12587                         } else {
12588                                 r->monitor_name = NULL;
12589                         }
12590                         ndr->flags = _flags_save_string;
12591                 }
12592                 {
12593                         uint32_t _flags_save_string = ndr->flags;
12594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12595                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12596                         if (_ptr_default_datatype) {
12597                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12598                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12599                         } else {
12600                                 r->default_datatype = NULL;
12601                         }
12602                         ndr->flags = _flags_save_string;
12603                 }
12604                 {
12605                         uint32_t _flags_save_string_array = ndr->flags;
12606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12607                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12608                         if (_ptr_dependent_files) {
12609                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12610                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12611                         } else {
12612                                 r->dependent_files = NULL;
12613                         }
12614                         ndr->flags = _flags_save_string_array;
12615                 }
12616                 {
12617                         uint32_t _flags_save_string_array = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12620                         if (_ptr_previous_names) {
12621                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12622                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12623                         } else {
12624                                 r->previous_names = NULL;
12625                         }
12626                         ndr->flags = _flags_save_string_array;
12627                 }
12628                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12629                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12630                 {
12631                         uint32_t _flags_save_string = ndr->flags;
12632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12633                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12634                         if (_ptr_manufacturer_name) {
12635                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12636                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12637                         } else {
12638                                 r->manufacturer_name = NULL;
12639                         }
12640                         ndr->flags = _flags_save_string;
12641                 }
12642                 {
12643                         uint32_t _flags_save_string = ndr->flags;
12644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12646                         if (_ptr_manufacturer_url) {
12647                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12649                         } else {
12650                                 r->manufacturer_url = NULL;
12651                         }
12652                         ndr->flags = _flags_save_string;
12653                 }
12654                 {
12655                         uint32_t _flags_save_string = ndr->flags;
12656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12657                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12658                         if (_ptr_hardware_id) {
12659                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12660                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12661                         } else {
12662                                 r->hardware_id = NULL;
12663                         }
12664                         ndr->flags = _flags_save_string;
12665                 }
12666                 {
12667                         uint32_t _flags_save_string = ndr->flags;
12668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12670                         if (_ptr_provider) {
12671                                 NDR_PULL_ALLOC(ndr, r->provider);
12672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12673                         } else {
12674                                 r->provider = NULL;
12675                         }
12676                         ndr->flags = _flags_save_string;
12677                 }
12678                 {
12679                         uint32_t _flags_save_string = ndr->flags;
12680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12682                         if (_ptr_print_processor) {
12683                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12685                         } else {
12686                                 r->print_processor = NULL;
12687                         }
12688                         ndr->flags = _flags_save_string;
12689                 }
12690                 {
12691                         uint32_t _flags_save_string = ndr->flags;
12692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12694                         if (_ptr_vendor_setup) {
12695                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12697                         } else {
12698                                 r->vendor_setup = NULL;
12699                         }
12700                         ndr->flags = _flags_save_string;
12701                 }
12702                 {
12703                         uint32_t _flags_save_string_array = ndr->flags;
12704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12706                         if (_ptr_color_profiles) {
12707                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12709                         } else {
12710                                 r->color_profiles = NULL;
12711                         }
12712                         ndr->flags = _flags_save_string_array;
12713                 }
12714                 {
12715                         uint32_t _flags_save_string = ndr->flags;
12716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12718                         if (_ptr_inf_path) {
12719                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12721                         } else {
12722                                 r->inf_path = NULL;
12723                         }
12724                         ndr->flags = _flags_save_string;
12725                 }
12726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12727                 {
12728                         uint32_t _flags_save_string_array = ndr->flags;
12729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12731                         if (_ptr_core_driver_dependencies) {
12732                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12734                         } else {
12735                                 r->core_driver_dependencies = NULL;
12736                         }
12737                         ndr->flags = _flags_save_string_array;
12738                 }
12739                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12740                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12741         }
12742         if (ndr_flags & NDR_BUFFERS) {
12743                 {
12744                         uint32_t _flags_save_string = ndr->flags;
12745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12746                         if (r->driver_name) {
12747                                 uint32_t _relative_save_offset;
12748                                 _relative_save_offset = ndr->offset;
12749                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12750                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12751                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12752                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12753                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12754                                 ndr->offset = _relative_save_offset;
12755                         }
12756                         ndr->flags = _flags_save_string;
12757                 }
12758                 {
12759                         uint32_t _flags_save_string = ndr->flags;
12760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12761                         if (r->architecture) {
12762                                 uint32_t _relative_save_offset;
12763                                 _relative_save_offset = ndr->offset;
12764                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12765                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12766                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12767                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12768                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12769                                 ndr->offset = _relative_save_offset;
12770                         }
12771                         ndr->flags = _flags_save_string;
12772                 }
12773                 {
12774                         uint32_t _flags_save_string = ndr->flags;
12775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12776                         if (r->driver_path) {
12777                                 uint32_t _relative_save_offset;
12778                                 _relative_save_offset = ndr->offset;
12779                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12780                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12781                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12782                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12783                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12784                                 ndr->offset = _relative_save_offset;
12785                         }
12786                         ndr->flags = _flags_save_string;
12787                 }
12788                 {
12789                         uint32_t _flags_save_string = ndr->flags;
12790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12791                         if (r->data_file) {
12792                                 uint32_t _relative_save_offset;
12793                                 _relative_save_offset = ndr->offset;
12794                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12795                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12796                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12797                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12798                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12799                                 ndr->offset = _relative_save_offset;
12800                         }
12801                         ndr->flags = _flags_save_string;
12802                 }
12803                 {
12804                         uint32_t _flags_save_string = ndr->flags;
12805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12806                         if (r->config_file) {
12807                                 uint32_t _relative_save_offset;
12808                                 _relative_save_offset = ndr->offset;
12809                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12810                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12811                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12812                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12813                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12814                                 ndr->offset = _relative_save_offset;
12815                         }
12816                         ndr->flags = _flags_save_string;
12817                 }
12818                 {
12819                         uint32_t _flags_save_string = ndr->flags;
12820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12821                         if (r->help_file) {
12822                                 uint32_t _relative_save_offset;
12823                                 _relative_save_offset = ndr->offset;
12824                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12825                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12826                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12827                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12828                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12829                                 ndr->offset = _relative_save_offset;
12830                         }
12831                         ndr->flags = _flags_save_string;
12832                 }
12833                 {
12834                         uint32_t _flags_save_string = ndr->flags;
12835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12836                         if (r->monitor_name) {
12837                                 uint32_t _relative_save_offset;
12838                                 _relative_save_offset = ndr->offset;
12839                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12840                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12841                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12842                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12843                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12844                                 ndr->offset = _relative_save_offset;
12845                         }
12846                         ndr->flags = _flags_save_string;
12847                 }
12848                 {
12849                         uint32_t _flags_save_string = ndr->flags;
12850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12851                         if (r->default_datatype) {
12852                                 uint32_t _relative_save_offset;
12853                                 _relative_save_offset = ndr->offset;
12854                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12855                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12856                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12857                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12858                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12859                                 ndr->offset = _relative_save_offset;
12860                         }
12861                         ndr->flags = _flags_save_string;
12862                 }
12863                 {
12864                         uint32_t _flags_save_string_array = ndr->flags;
12865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12866                         if (r->dependent_files) {
12867                                 uint32_t _relative_save_offset;
12868                                 _relative_save_offset = ndr->offset;
12869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12870                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12871                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12872                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12874                                 ndr->offset = _relative_save_offset;
12875                         }
12876                         ndr->flags = _flags_save_string_array;
12877                 }
12878                 {
12879                         uint32_t _flags_save_string_array = ndr->flags;
12880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12881                         if (r->previous_names) {
12882                                 uint32_t _relative_save_offset;
12883                                 _relative_save_offset = ndr->offset;
12884                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12885                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12886                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12887                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12888                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12889                                 ndr->offset = _relative_save_offset;
12890                         }
12891                         ndr->flags = _flags_save_string_array;
12892                 }
12893                 {
12894                         uint32_t _flags_save_string = ndr->flags;
12895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12896                         if (r->manufacturer_name) {
12897                                 uint32_t _relative_save_offset;
12898                                 _relative_save_offset = ndr->offset;
12899                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12900                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12901                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12902                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12903                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12904                                 ndr->offset = _relative_save_offset;
12905                         }
12906                         ndr->flags = _flags_save_string;
12907                 }
12908                 {
12909                         uint32_t _flags_save_string = ndr->flags;
12910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12911                         if (r->manufacturer_url) {
12912                                 uint32_t _relative_save_offset;
12913                                 _relative_save_offset = ndr->offset;
12914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12915                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12916                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12917                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12918                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12919                                 ndr->offset = _relative_save_offset;
12920                         }
12921                         ndr->flags = _flags_save_string;
12922                 }
12923                 {
12924                         uint32_t _flags_save_string = ndr->flags;
12925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12926                         if (r->hardware_id) {
12927                                 uint32_t _relative_save_offset;
12928                                 _relative_save_offset = ndr->offset;
12929                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12930                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12931                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12932                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12933                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12934                                 ndr->offset = _relative_save_offset;
12935                         }
12936                         ndr->flags = _flags_save_string;
12937                 }
12938                 {
12939                         uint32_t _flags_save_string = ndr->flags;
12940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12941                         if (r->provider) {
12942                                 uint32_t _relative_save_offset;
12943                                 _relative_save_offset = ndr->offset;
12944                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12945                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12946                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12947                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12948                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12949                                 ndr->offset = _relative_save_offset;
12950                         }
12951                         ndr->flags = _flags_save_string;
12952                 }
12953                 {
12954                         uint32_t _flags_save_string = ndr->flags;
12955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12956                         if (r->print_processor) {
12957                                 uint32_t _relative_save_offset;
12958                                 _relative_save_offset = ndr->offset;
12959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
12960                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
12961                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
12962                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
12963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
12964                                 ndr->offset = _relative_save_offset;
12965                         }
12966                         ndr->flags = _flags_save_string;
12967                 }
12968                 {
12969                         uint32_t _flags_save_string = ndr->flags;
12970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12971                         if (r->vendor_setup) {
12972                                 uint32_t _relative_save_offset;
12973                                 _relative_save_offset = ndr->offset;
12974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
12975                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
12976                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
12977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
12978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
12979                                 ndr->offset = _relative_save_offset;
12980                         }
12981                         ndr->flags = _flags_save_string;
12982                 }
12983                 {
12984                         uint32_t _flags_save_string_array = ndr->flags;
12985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12986                         if (r->color_profiles) {
12987                                 uint32_t _relative_save_offset;
12988                                 _relative_save_offset = ndr->offset;
12989                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
12990                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
12991                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
12992                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
12993                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
12994                                 ndr->offset = _relative_save_offset;
12995                         }
12996                         ndr->flags = _flags_save_string_array;
12997                 }
12998                 {
12999                         uint32_t _flags_save_string = ndr->flags;
13000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13001                         if (r->inf_path) {
13002                                 uint32_t _relative_save_offset;
13003                                 _relative_save_offset = ndr->offset;
13004                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13005                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13006                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13007                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13008                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13009                                 ndr->offset = _relative_save_offset;
13010                         }
13011                         ndr->flags = _flags_save_string;
13012                 }
13013                 {
13014                         uint32_t _flags_save_string_array = ndr->flags;
13015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13016                         if (r->core_driver_dependencies) {
13017                                 uint32_t _relative_save_offset;
13018                                 _relative_save_offset = ndr->offset;
13019                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13020                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13021                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13022                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13023                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13024                                 ndr->offset = _relative_save_offset;
13025                         }
13026                         ndr->flags = _flags_save_string_array;
13027                 }
13028         }
13029         return NDR_ERR_SUCCESS;
13030 }
13031
13032 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13033 {
13034         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13035         ndr->depth++;
13036         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13037         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13038         ndr->depth++;
13039         if (r->driver_name) {
13040                 ndr_print_string(ndr, "driver_name", r->driver_name);
13041         }
13042         ndr->depth--;
13043         ndr_print_ptr(ndr, "architecture", r->architecture);
13044         ndr->depth++;
13045         if (r->architecture) {
13046                 ndr_print_string(ndr, "architecture", r->architecture);
13047         }
13048         ndr->depth--;
13049         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13050         ndr->depth++;
13051         if (r->driver_path) {
13052                 ndr_print_string(ndr, "driver_path", r->driver_path);
13053         }
13054         ndr->depth--;
13055         ndr_print_ptr(ndr, "data_file", r->data_file);
13056         ndr->depth++;
13057         if (r->data_file) {
13058                 ndr_print_string(ndr, "data_file", r->data_file);
13059         }
13060         ndr->depth--;
13061         ndr_print_ptr(ndr, "config_file", r->config_file);
13062         ndr->depth++;
13063         if (r->config_file) {
13064                 ndr_print_string(ndr, "config_file", r->config_file);
13065         }
13066         ndr->depth--;
13067         ndr_print_ptr(ndr, "help_file", r->help_file);
13068         ndr->depth++;
13069         if (r->help_file) {
13070                 ndr_print_string(ndr, "help_file", r->help_file);
13071         }
13072         ndr->depth--;
13073         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13074         ndr->depth++;
13075         if (r->monitor_name) {
13076                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13077         }
13078         ndr->depth--;
13079         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13080         ndr->depth++;
13081         if (r->default_datatype) {
13082                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13083         }
13084         ndr->depth--;
13085         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13086         ndr->depth++;
13087         if (r->dependent_files) {
13088                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13089         }
13090         ndr->depth--;
13091         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13092         ndr->depth++;
13093         if (r->previous_names) {
13094                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13095         }
13096         ndr->depth--;
13097         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13098         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13099         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13100         ndr->depth++;
13101         if (r->manufacturer_name) {
13102                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13103         }
13104         ndr->depth--;
13105         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13106         ndr->depth++;
13107         if (r->manufacturer_url) {
13108                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13109         }
13110         ndr->depth--;
13111         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13112         ndr->depth++;
13113         if (r->hardware_id) {
13114                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13115         }
13116         ndr->depth--;
13117         ndr_print_ptr(ndr, "provider", r->provider);
13118         ndr->depth++;
13119         if (r->provider) {
13120                 ndr_print_string(ndr, "provider", r->provider);
13121         }
13122         ndr->depth--;
13123         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13124         ndr->depth++;
13125         if (r->print_processor) {
13126                 ndr_print_string(ndr, "print_processor", r->print_processor);
13127         }
13128         ndr->depth--;
13129         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13130         ndr->depth++;
13131         if (r->vendor_setup) {
13132                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13133         }
13134         ndr->depth--;
13135         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13136         ndr->depth++;
13137         if (r->color_profiles) {
13138                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13139         }
13140         ndr->depth--;
13141         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13142         ndr->depth++;
13143         if (r->inf_path) {
13144                 ndr_print_string(ndr, "inf_path", r->inf_path);
13145         }
13146         ndr->depth--;
13147         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13148         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13149         ndr->depth++;
13150         if (r->core_driver_dependencies) {
13151                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13152         }
13153         ndr->depth--;
13154         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13155         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13156         ndr->depth--;
13157 }
13158
13159 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13160 {
13161         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13162 }
13163
13164 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13165 {
13166         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13167         return NDR_ERR_SUCCESS;
13168 }
13169
13170 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13171 {
13172         uint32_t v;
13173         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13174         *r = v;
13175         return NDR_ERR_SUCCESS;
13176 }
13177
13178 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13179 {
13180         const char *val = NULL;
13181
13182         switch (r) {
13183                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13184                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13185                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13186                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13187                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13188         }
13189         ndr_print_enum(ndr, name, "ENUM", val, r);
13190 }
13191
13192 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13193 {
13194         if (ndr_flags & NDR_SCALARS) {
13195                 NDR_CHECK(ndr_push_align(ndr, 4));
13196                 {
13197                         uint32_t _flags_save_string = ndr->flags;
13198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13199                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13200                         ndr->flags = _flags_save_string;
13201                 }
13202                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13204         }
13205         if (ndr_flags & NDR_BUFFERS) {
13206                 {
13207                         uint32_t _flags_save_string = ndr->flags;
13208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13209                         if (r->file_name) {
13210                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13211                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13212                         }
13213                         ndr->flags = _flags_save_string;
13214                 }
13215         }
13216         return NDR_ERR_SUCCESS;
13217 }
13218
13219 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13220 {
13221         uint32_t _ptr_file_name;
13222         TALLOC_CTX *_mem_save_file_name_0;
13223         if (ndr_flags & NDR_SCALARS) {
13224                 NDR_CHECK(ndr_pull_align(ndr, 4));
13225                 {
13226                         uint32_t _flags_save_string = ndr->flags;
13227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13229                         if (_ptr_file_name) {
13230                                 NDR_PULL_ALLOC(ndr, r->file_name);
13231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13232                         } else {
13233                                 r->file_name = NULL;
13234                         }
13235                         ndr->flags = _flags_save_string;
13236                 }
13237                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13239         }
13240         if (ndr_flags & NDR_BUFFERS) {
13241                 {
13242                         uint32_t _flags_save_string = ndr->flags;
13243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13244                         if (r->file_name) {
13245                                 uint32_t _relative_save_offset;
13246                                 _relative_save_offset = ndr->offset;
13247                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13248                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13249                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13250                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13251                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13252                                 ndr->offset = _relative_save_offset;
13253                         }
13254                         ndr->flags = _flags_save_string;
13255                 }
13256         }
13257         return NDR_ERR_SUCCESS;
13258 }
13259
13260 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13261 {
13262         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13263         ndr->depth++;
13264         ndr_print_ptr(ndr, "file_name", r->file_name);
13265         ndr->depth++;
13266         if (r->file_name) {
13267                 ndr_print_string(ndr, "file_name", r->file_name);
13268         }
13269         ndr->depth--;
13270         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13271         ndr_print_uint32(ndr, "file_version", r->file_version);
13272         ndr->depth--;
13273 }
13274
13275 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13276 {
13277         uint32_t cntr_file_info_1;
13278         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13279         ndr->depth++;
13280         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13281         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13282         ndr->depth++;
13283         if (r->driver_name) {
13284                 ndr_print_string(ndr, "driver_name", r->driver_name);
13285         }
13286         ndr->depth--;
13287         ndr_print_ptr(ndr, "architecture", r->architecture);
13288         ndr->depth++;
13289         if (r->architecture) {
13290                 ndr_print_string(ndr, "architecture", r->architecture);
13291         }
13292         ndr->depth--;
13293         ndr_print_ptr(ndr, "file_info", r->file_info);
13294         ndr->depth++;
13295         if (r->file_info) {
13296                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13297                 ndr->depth++;
13298                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13299                         char *idx_1=NULL;
13300                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13301                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13302                                 free(idx_1);
13303                         }
13304                 }
13305                 ndr->depth--;
13306         }
13307         ndr->depth--;
13308         ndr_print_uint32(ndr, "file_count", r->file_count);
13309         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13310         ndr->depth++;
13311         if (r->monitor_name) {
13312                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13313         }
13314         ndr->depth--;
13315         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13316         ndr->depth++;
13317         if (r->default_datatype) {
13318                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13319         }
13320         ndr->depth--;
13321         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13322         ndr->depth++;
13323         if (r->previous_names) {
13324                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13325         }
13326         ndr->depth--;
13327         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13328         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13329         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13330         ndr->depth++;
13331         if (r->manufacturer_name) {
13332                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13333         }
13334         ndr->depth--;
13335         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13336         ndr->depth++;
13337         if (r->manufacturer_url) {
13338                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13339         }
13340         ndr->depth--;
13341         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13342         ndr->depth++;
13343         if (r->hardware_id) {
13344                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13345         }
13346         ndr->depth--;
13347         ndr_print_ptr(ndr, "provider", r->provider);
13348         ndr->depth++;
13349         if (r->provider) {
13350                 ndr_print_string(ndr, "provider", r->provider);
13351         }
13352         ndr->depth--;
13353         ndr->depth--;
13354 }
13355
13356 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13357 {
13358         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13359 }
13360
13361 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13362 {
13363         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13364         if (ndr_flags & NDR_SCALARS) {
13365                 int level = ndr_push_get_switch_value(ndr, r);
13366                 switch (level) {
13367                         case 1: {
13368                                 NDR_CHECK(ndr_push_align(ndr, 4));
13369                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13370                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13371                         break; }
13372
13373                         case 2: {
13374                                 NDR_CHECK(ndr_push_align(ndr, 4));
13375                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13376                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13377                         break; }
13378
13379                         case 3: {
13380                                 NDR_CHECK(ndr_push_align(ndr, 4));
13381                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13382                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13383                         break; }
13384
13385                         case 4: {
13386                                 NDR_CHECK(ndr_push_align(ndr, 4));
13387                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13388                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13389                         break; }
13390
13391                         case 5: {
13392                                 NDR_CHECK(ndr_push_align(ndr, 4));
13393                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13394                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13395                         break; }
13396
13397                         case 6: {
13398                                 NDR_CHECK(ndr_push_align(ndr, 8));
13399                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13400                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13401                         break; }
13402
13403                         case 8: {
13404                                 NDR_CHECK(ndr_push_align(ndr, 8));
13405                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13406                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13407                         break; }
13408
13409                         case 101: {
13410                                 NDR_CHECK(ndr_push_align(ndr, 8));
13411                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13412                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13413                         break; }
13414
13415                         default: {
13416                         break; }
13417
13418                 }
13419         }
13420         if (ndr_flags & NDR_BUFFERS) {
13421                 int level = ndr_push_get_switch_value(ndr, r);
13422                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13423                 switch (level) {
13424                         case 1:
13425                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13426                         break;
13427
13428                         case 2:
13429                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13430                         break;
13431
13432                         case 3:
13433                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13434                         break;
13435
13436                         case 4:
13437                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13438                         break;
13439
13440                         case 5:
13441                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13442                         break;
13443
13444                         case 6:
13445                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13446                         break;
13447
13448                         case 8:
13449                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13450                         break;
13451
13452                         case 101:
13453                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13454                         break;
13455
13456                         default:
13457                         break;
13458
13459                 }
13460         }
13461         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13462         return NDR_ERR_SUCCESS;
13463 }
13464
13465 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13466 {
13467         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13468         int level;
13469         level = ndr_pull_get_switch_value(ndr, r);
13470         if (ndr_flags & NDR_SCALARS) {
13471                 switch (level) {
13472                         case 1: {
13473                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13474                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13475                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13476                         break; }
13477
13478                         case 2: {
13479                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13480                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13481                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13482                         break; }
13483
13484                         case 3: {
13485                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13486                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13487                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13488                         break; }
13489
13490                         case 4: {
13491                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13492                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13493                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13494                         break; }
13495
13496                         case 5: {
13497                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13498                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13499                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13500                         break; }
13501
13502                         case 6: {
13503                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13504                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13505                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13506                         break; }
13507
13508                         case 8: {
13509                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13510                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13511                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13512                         break; }
13513
13514                         case 101: {
13515                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13516                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13517                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13518                         break; }
13519
13520                         default: {
13521                         break; }
13522
13523                 }
13524         }
13525         if (ndr_flags & NDR_BUFFERS) {
13526                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13527                 switch (level) {
13528                         case 1:
13529                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13530                         break;
13531
13532                         case 2:
13533                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13534                         break;
13535
13536                         case 3:
13537                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13538                         break;
13539
13540                         case 4:
13541                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13542                         break;
13543
13544                         case 5:
13545                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13546                         break;
13547
13548                         case 6:
13549                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13550                         break;
13551
13552                         case 8:
13553                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13554                         break;
13555
13556                         case 101:
13557                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13558                         break;
13559
13560                         default:
13561                         break;
13562
13563                 }
13564         }
13565         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13566         return NDR_ERR_SUCCESS;
13567 }
13568
13569 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13570 {
13571         int level;
13572         level = ndr_print_get_switch_value(ndr, r);
13573         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13574         switch (level) {
13575                 case 1:
13576                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13577                 break;
13578
13579                 case 2:
13580                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13581                 break;
13582
13583                 case 3:
13584                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13585                 break;
13586
13587                 case 4:
13588                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13589                 break;
13590
13591                 case 5:
13592                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13593                 break;
13594
13595                 case 6:
13596                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13597                 break;
13598
13599                 case 8:
13600                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13601                 break;
13602
13603                 case 101:
13604                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13605                 break;
13606
13607                 default:
13608                 break;
13609
13610         }
13611 }
13612
13613 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13614 {
13615         if (ndr_flags & NDR_SCALARS) {
13616                 NDR_CHECK(ndr_push_align(ndr, 4));
13617                 {
13618                         uint32_t _flags_save_string = ndr->flags;
13619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13620                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13621                         ndr->flags = _flags_save_string;
13622                 }
13623         }
13624         if (ndr_flags & NDR_BUFFERS) {
13625         }
13626         return NDR_ERR_SUCCESS;
13627 }
13628
13629 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13630 {
13631         if (ndr_flags & NDR_SCALARS) {
13632                 NDR_CHECK(ndr_pull_align(ndr, 4));
13633                 {
13634                         uint32_t _flags_save_string = ndr->flags;
13635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13636                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13637                         ndr->flags = _flags_save_string;
13638                 }
13639         }
13640         if (ndr_flags & NDR_BUFFERS) {
13641         }
13642         return NDR_ERR_SUCCESS;
13643 }
13644
13645 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13646 {
13647         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13648         ndr->depth++;
13649         ndr_print_string(ndr, "directory_name", r->directory_name);
13650         ndr->depth--;
13651 }
13652
13653 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13654 {
13655         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13656 }
13657
13658 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13659 {
13660         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13661         if (ndr_flags & NDR_SCALARS) {
13662                 int level = ndr_push_get_switch_value(ndr, r);
13663                 switch (level) {
13664                         case 1: {
13665                                 NDR_CHECK(ndr_push_align(ndr, 4));
13666                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13667                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13668                         break; }
13669
13670                         default: {
13671                                 NDR_CHECK(ndr_push_align(ndr, 4));
13672                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13673                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13674                         break; }
13675
13676                 }
13677         }
13678         if (ndr_flags & NDR_BUFFERS) {
13679                 int level = ndr_push_get_switch_value(ndr, r);
13680                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13681                 switch (level) {
13682                         case 1:
13683                         break;
13684
13685                         default:
13686                         break;
13687
13688                 }
13689         }
13690         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13691         return NDR_ERR_SUCCESS;
13692 }
13693
13694 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13695 {
13696         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13697         int level;
13698         level = ndr_pull_get_switch_value(ndr, r);
13699         if (ndr_flags & NDR_SCALARS) {
13700                 switch (level) {
13701                         case 1: {
13702                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13703                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13704                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13705                         break; }
13706
13707                         default: {
13708                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13709                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13710                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13711                         break; }
13712
13713                 }
13714         }
13715         if (ndr_flags & NDR_BUFFERS) {
13716                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13717                 switch (level) {
13718                         case 1:
13719                         break;
13720
13721                         default:
13722                         break;
13723
13724                 }
13725         }
13726         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13727         return NDR_ERR_SUCCESS;
13728 }
13729
13730 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13731 {
13732         int level;
13733         level = ndr_print_get_switch_value(ndr, r);
13734         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13735         switch (level) {
13736                 case 1:
13737                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13738                 break;
13739
13740                 default:
13741                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13742                 break;
13743
13744         }
13745 }
13746
13747 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13748 {
13749         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13750 }
13751
13752 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13753 {
13754         if (ndr_flags & NDR_SCALARS) {
13755                 NDR_CHECK(ndr_push_align(ndr, 4));
13756                 {
13757                         uint32_t _flags_save_string = ndr->flags;
13758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13759                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13760                         ndr->flags = _flags_save_string;
13761                 }
13762         }
13763         if (ndr_flags & NDR_BUFFERS) {
13764                 {
13765                         uint32_t _flags_save_string = ndr->flags;
13766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13767                         if (r->print_processor_name) {
13768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13770                         }
13771                         ndr->flags = _flags_save_string;
13772                 }
13773         }
13774         return NDR_ERR_SUCCESS;
13775 }
13776
13777 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13778 {
13779         uint32_t _ptr_print_processor_name;
13780         TALLOC_CTX *_mem_save_print_processor_name_0;
13781         if (ndr_flags & NDR_SCALARS) {
13782                 NDR_CHECK(ndr_pull_align(ndr, 4));
13783                 {
13784                         uint32_t _flags_save_string = ndr->flags;
13785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13786                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13787                         if (_ptr_print_processor_name) {
13788                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13789                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13790                         } else {
13791                                 r->print_processor_name = NULL;
13792                         }
13793                         ndr->flags = _flags_save_string;
13794                 }
13795         }
13796         if (ndr_flags & NDR_BUFFERS) {
13797                 {
13798                         uint32_t _flags_save_string = ndr->flags;
13799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13800                         if (r->print_processor_name) {
13801                                 uint32_t _relative_save_offset;
13802                                 _relative_save_offset = ndr->offset;
13803                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13804                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13805                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13806                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13807                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13808                                 ndr->offset = _relative_save_offset;
13809                         }
13810                         ndr->flags = _flags_save_string;
13811                 }
13812         }
13813         return NDR_ERR_SUCCESS;
13814 }
13815
13816 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13817 {
13818         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13819         ndr->depth++;
13820         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13821         ndr->depth++;
13822         if (r->print_processor_name) {
13823                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13824         }
13825         ndr->depth--;
13826         ndr->depth--;
13827 }
13828
13829 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13830 {
13831         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13832 }
13833
13834 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13835 {
13836         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13837         if (ndr_flags & NDR_SCALARS) {
13838                 int level = ndr_push_get_switch_value(ndr, r);
13839                 switch (level) {
13840                         case 1: {
13841                                 NDR_CHECK(ndr_push_align(ndr, 4));
13842                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13843                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13844                         break; }
13845
13846                         default: {
13847                         break; }
13848
13849                 }
13850         }
13851         if (ndr_flags & NDR_BUFFERS) {
13852                 int level = ndr_push_get_switch_value(ndr, r);
13853                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13854                 switch (level) {
13855                         case 1:
13856                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13857                         break;
13858
13859                         default:
13860                         break;
13861
13862                 }
13863         }
13864         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13865         return NDR_ERR_SUCCESS;
13866 }
13867
13868 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13869 {
13870         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13871         int level;
13872         level = ndr_pull_get_switch_value(ndr, r);
13873         if (ndr_flags & NDR_SCALARS) {
13874                 switch (level) {
13875                         case 1: {
13876                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13877                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13878                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13879                         break; }
13880
13881                         default: {
13882                         break; }
13883
13884                 }
13885         }
13886         if (ndr_flags & NDR_BUFFERS) {
13887                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13888                 switch (level) {
13889                         case 1:
13890                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13891                         break;
13892
13893                         default:
13894                         break;
13895
13896                 }
13897         }
13898         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13899         return NDR_ERR_SUCCESS;
13900 }
13901
13902 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13903 {
13904         int level;
13905         level = ndr_print_get_switch_value(ndr, r);
13906         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13907         switch (level) {
13908                 case 1:
13909                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13910                 break;
13911
13912                 default:
13913                 break;
13914
13915         }
13916 }
13917
13918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13919 {
13920         if (ndr_flags & NDR_SCALARS) {
13921                 NDR_CHECK(ndr_push_align(ndr, 4));
13922                 {
13923                         uint32_t _flags_save_string = ndr->flags;
13924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13925                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13926                         ndr->flags = _flags_save_string;
13927                 }
13928         }
13929         if (ndr_flags & NDR_BUFFERS) {
13930         }
13931         return NDR_ERR_SUCCESS;
13932 }
13933
13934 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
13935 {
13936         if (ndr_flags & NDR_SCALARS) {
13937                 NDR_CHECK(ndr_pull_align(ndr, 4));
13938                 {
13939                         uint32_t _flags_save_string = ndr->flags;
13940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13941                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13942                         ndr->flags = _flags_save_string;
13943                 }
13944         }
13945         if (ndr_flags & NDR_BUFFERS) {
13946         }
13947         return NDR_ERR_SUCCESS;
13948 }
13949
13950 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13951 {
13952         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
13953         ndr->depth++;
13954         ndr_print_string(ndr, "directory_name", r->directory_name);
13955         ndr->depth--;
13956 }
13957
13958 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13959 {
13960         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
13961 }
13962
13963 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
13964 {
13965         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13966         if (ndr_flags & NDR_SCALARS) {
13967                 int level = ndr_push_get_switch_value(ndr, r);
13968                 switch (level) {
13969                         case 1: {
13970                                 NDR_CHECK(ndr_push_align(ndr, 4));
13971                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13972                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13973                         break; }
13974
13975                         default: {
13976                                 NDR_CHECK(ndr_push_align(ndr, 4));
13977                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13978                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13979                         break; }
13980
13981                 }
13982         }
13983         if (ndr_flags & NDR_BUFFERS) {
13984                 int level = ndr_push_get_switch_value(ndr, r);
13985                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13986                 switch (level) {
13987                         case 1:
13988                         break;
13989
13990                         default:
13991                         break;
13992
13993                 }
13994         }
13995         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13996         return NDR_ERR_SUCCESS;
13997 }
13998
13999 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14000 {
14001         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14002         int level;
14003         level = ndr_pull_get_switch_value(ndr, r);
14004         if (ndr_flags & NDR_SCALARS) {
14005                 switch (level) {
14006                         case 1: {
14007                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14008                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14009                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14010                         break; }
14011
14012                         default: {
14013                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14014                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14015                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14016                         break; }
14017
14018                 }
14019         }
14020         if (ndr_flags & NDR_BUFFERS) {
14021                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14022                 switch (level) {
14023                         case 1:
14024                         break;
14025
14026                         default:
14027                         break;
14028
14029                 }
14030         }
14031         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14032         return NDR_ERR_SUCCESS;
14033 }
14034
14035 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14036 {
14037         int level;
14038         level = ndr_print_get_switch_value(ndr, r);
14039         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14040         switch (level) {
14041                 case 1:
14042                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14043                 break;
14044
14045                 default:
14046                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14047                 break;
14048
14049         }
14050 }
14051
14052 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14053 {
14054         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14055 }
14056
14057 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14058 {
14059         if (ndr_flags & NDR_SCALARS) {
14060                 NDR_CHECK(ndr_push_align(ndr, 4));
14061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14064         }
14065         if (ndr_flags & NDR_BUFFERS) {
14066                 if (r->document_name) {
14067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14070                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14071                 }
14072                 if (r->output_file) {
14073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14076                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14077                 }
14078                 if (r->datatype) {
14079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14082                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14083                 }
14084         }
14085         return NDR_ERR_SUCCESS;
14086 }
14087
14088 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14089 {
14090         uint32_t _ptr_document_name;
14091         TALLOC_CTX *_mem_save_document_name_0;
14092         uint32_t _ptr_output_file;
14093         TALLOC_CTX *_mem_save_output_file_0;
14094         uint32_t _ptr_datatype;
14095         TALLOC_CTX *_mem_save_datatype_0;
14096         if (ndr_flags & NDR_SCALARS) {
14097                 NDR_CHECK(ndr_pull_align(ndr, 4));
14098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14099                 if (_ptr_document_name) {
14100                         NDR_PULL_ALLOC(ndr, r->document_name);
14101                 } else {
14102                         r->document_name = NULL;
14103                 }
14104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14105                 if (_ptr_output_file) {
14106                         NDR_PULL_ALLOC(ndr, r->output_file);
14107                 } else {
14108                         r->output_file = NULL;
14109                 }
14110                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14111                 if (_ptr_datatype) {
14112                         NDR_PULL_ALLOC(ndr, r->datatype);
14113                 } else {
14114                         r->datatype = NULL;
14115                 }
14116         }
14117         if (ndr_flags & NDR_BUFFERS) {
14118                 if (r->document_name) {
14119                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14120                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14122                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14123                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14124                                 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));
14125                         }
14126                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14127                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14129                 }
14130                 if (r->output_file) {
14131                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14132                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14133                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14134                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14135                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14136                                 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));
14137                         }
14138                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14139                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14141                 }
14142                 if (r->datatype) {
14143                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14144                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14145                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14146                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14147                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14148                                 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));
14149                         }
14150                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14151                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14153                 }
14154         }
14155         return NDR_ERR_SUCCESS;
14156 }
14157
14158 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14159 {
14160         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14161         ndr->depth++;
14162         ndr_print_ptr(ndr, "document_name", r->document_name);
14163         ndr->depth++;
14164         if (r->document_name) {
14165                 ndr_print_string(ndr, "document_name", r->document_name);
14166         }
14167         ndr->depth--;
14168         ndr_print_ptr(ndr, "output_file", r->output_file);
14169         ndr->depth++;
14170         if (r->output_file) {
14171                 ndr_print_string(ndr, "output_file", r->output_file);
14172         }
14173         ndr->depth--;
14174         ndr_print_ptr(ndr, "datatype", r->datatype);
14175         ndr->depth++;
14176         if (r->datatype) {
14177                 ndr_print_string(ndr, "datatype", r->datatype);
14178         }
14179         ndr->depth--;
14180         ndr->depth--;
14181 }
14182
14183 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14184 {
14185         if (ndr_flags & NDR_SCALARS) {
14186                 int level = ndr_push_get_switch_value(ndr, r);
14187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14188                 switch (level) {
14189                         case 1: {
14190                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14191                         break; }
14192
14193                         case 2: {
14194                         break; }
14195
14196                         case 3: {
14197                         break; }
14198
14199                         default: {
14200                         break; }
14201
14202                 }
14203         }
14204         if (ndr_flags & NDR_BUFFERS) {
14205                 int level = ndr_push_get_switch_value(ndr, r);
14206                 switch (level) {
14207                         case 1:
14208                                 if (r->info1) {
14209                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14210                                 }
14211                         break;
14212
14213                         case 2:
14214                         break;
14215
14216                         case 3:
14217                         break;
14218
14219                         default:
14220                         break;
14221
14222                 }
14223         }
14224         return NDR_ERR_SUCCESS;
14225 }
14226
14227 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14228 {
14229         int level;
14230         uint32_t _level;
14231         TALLOC_CTX *_mem_save_info1_0;
14232         level = ndr_pull_get_switch_value(ndr, r);
14233         if (ndr_flags & NDR_SCALARS) {
14234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14235                 if (_level != level) {
14236                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14237                 }
14238                 switch (level) {
14239                         case 1: {
14240                                 uint32_t _ptr_info1;
14241                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14242                                 if (_ptr_info1) {
14243                                         NDR_PULL_ALLOC(ndr, r->info1);
14244                                 } else {
14245                                         r->info1 = NULL;
14246                                 }
14247                         break; }
14248
14249                         case 2: {
14250                         break; }
14251
14252                         case 3: {
14253                         break; }
14254
14255                         default: {
14256                         break; }
14257
14258                 }
14259         }
14260         if (ndr_flags & NDR_BUFFERS) {
14261                 switch (level) {
14262                         case 1:
14263                                 if (r->info1) {
14264                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14265                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14266                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14267                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14268                                 }
14269                         break;
14270
14271                         case 2:
14272                         break;
14273
14274                         case 3:
14275                         break;
14276
14277                         default:
14278                         break;
14279
14280                 }
14281         }
14282         return NDR_ERR_SUCCESS;
14283 }
14284
14285 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14286 {
14287         int level;
14288         level = ndr_print_get_switch_value(ndr, r);
14289         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14290         switch (level) {
14291                 case 1:
14292                         ndr_print_ptr(ndr, "info1", r->info1);
14293                         ndr->depth++;
14294                         if (r->info1) {
14295                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14296                         }
14297                         ndr->depth--;
14298                 break;
14299
14300                 case 2:
14301                 break;
14302
14303                 case 3:
14304                 break;
14305
14306                 default:
14307                 break;
14308
14309         }
14310 }
14311
14312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14313 {
14314         if (ndr_flags & NDR_SCALARS) {
14315                 NDR_CHECK(ndr_push_align(ndr, 4));
14316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14321                 {
14322                         uint32_t _flags_save_string = ndr->flags;
14323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14324                         {
14325                                 struct ndr_push *_ndr_extra_string;
14326                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14327                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14328                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14329                         }
14330                         ndr->flags = _flags_save_string;
14331                 }
14332         }
14333         if (ndr_flags & NDR_BUFFERS) {
14334         }
14335         return NDR_ERR_SUCCESS;
14336 }
14337
14338 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14339 {
14340         if (ndr_flags & NDR_SCALARS) {
14341                 NDR_CHECK(ndr_pull_align(ndr, 4));
14342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14347                 {
14348                         uint32_t _flags_save_string = ndr->flags;
14349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14350                         {
14351                                 struct ndr_pull *_ndr_extra_string;
14352                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14353                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14354                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14355                         }
14356                         ndr->flags = _flags_save_string;
14357                 }
14358         }
14359         if (ndr_flags & NDR_BUFFERS) {
14360         }
14361         return NDR_ERR_SUCCESS;
14362 }
14363
14364 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14365 {
14366         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14367         ndr->depth++;
14368         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);
14369         ndr_print_uint32(ndr, "major", r->major);
14370         ndr_print_uint32(ndr, "minor", r->minor);
14371         ndr_print_uint32(ndr, "build", r->build);
14372         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14373         ndr_print_string(ndr, "extra_string", r->extra_string);
14374         ndr->depth--;
14375 }
14376
14377 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14378 {
14379         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14380 }
14381
14382 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14383 {
14384         if (ndr_flags & NDR_SCALARS) {
14385                 NDR_CHECK(ndr_push_align(ndr, 4));
14386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14391                 {
14392                         uint32_t _flags_save_string = ndr->flags;
14393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14394                         {
14395                                 struct ndr_push *_ndr_extra_string;
14396                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14397                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14398                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14399                         }
14400                         ndr->flags = _flags_save_string;
14401                 }
14402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14404         }
14405         if (ndr_flags & NDR_BUFFERS) {
14406         }
14407         return NDR_ERR_SUCCESS;
14408 }
14409
14410 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14411 {
14412         if (ndr_flags & NDR_SCALARS) {
14413                 NDR_CHECK(ndr_pull_align(ndr, 4));
14414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14419                 {
14420                         uint32_t _flags_save_string = ndr->flags;
14421                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14422                         {
14423                                 struct ndr_pull *_ndr_extra_string;
14424                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14425                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14426                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14427                         }
14428                         ndr->flags = _flags_save_string;
14429                 }
14430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14432         }
14433         if (ndr_flags & NDR_BUFFERS) {
14434         }
14435         return NDR_ERR_SUCCESS;
14436 }
14437
14438 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14439 {
14440         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14441         ndr->depth++;
14442         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);
14443         ndr_print_uint32(ndr, "major", r->major);
14444         ndr_print_uint32(ndr, "minor", r->minor);
14445         ndr_print_uint32(ndr, "build", r->build);
14446         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14447         ndr_print_string(ndr, "extra_string", r->extra_string);
14448         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14449         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14450         ndr->depth--;
14451 }
14452
14453 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14454 {
14455         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14456 }
14457
14458 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
14459 {
14460         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14461         return NDR_ERR_SUCCESS;
14462 }
14463
14464 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
14465 {
14466         uint32_t v;
14467         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14468         *r = v;
14469         return NDR_ERR_SUCCESS;
14470 }
14471
14472 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
14473 {
14474         const char *val = NULL;
14475
14476         switch (r) {
14477                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
14478                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
14479                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
14480                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
14481                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
14482         }
14483         ndr_print_enum(ndr, name, "ENUM", val, r);
14484 }
14485
14486 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14487 {
14488         if (ndr_flags & NDR_SCALARS) {
14489                 int level = ndr_push_get_switch_value(ndr, r);
14490                 switch (level) {
14491                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14492                         break; }
14493
14494                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14495                                 {
14496                                         uint32_t _flags_save_string = ndr->flags;
14497                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14498                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14499                                         ndr->flags = _flags_save_string;
14500                                 }
14501                         break; }
14502
14503                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14504                                 {
14505                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14506                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14507                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14508                                         ndr->flags = _flags_save_DATA_BLOB;
14509                                 }
14510                         break; }
14511
14512                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14513                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14514                         break; }
14515
14516                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14517                                 {
14518                                         uint32_t _flags_save_string_array = ndr->flags;
14519                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14520                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14521                                         ndr->flags = _flags_save_string_array;
14522                                 }
14523                         break; }
14524
14525                         default: {
14526                                 {
14527                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14528                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14529                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14530                                         ndr->flags = _flags_save_DATA_BLOB;
14531                                 }
14532                         break; }
14533
14534                 }
14535         }
14536         if (ndr_flags & NDR_BUFFERS) {
14537                 int level = ndr_push_get_switch_value(ndr, r);
14538                 switch (level) {
14539                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14540                         break;
14541
14542                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14543                         break;
14544
14545                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14546                         break;
14547
14548                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14549                         break;
14550
14551                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14552                         break;
14553
14554                         default:
14555                         break;
14556
14557                 }
14558         }
14559         return NDR_ERR_SUCCESS;
14560 }
14561
14562 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14563 {
14564         int level;
14565         level = ndr_pull_get_switch_value(ndr, r);
14566         if (ndr_flags & NDR_SCALARS) {
14567                 switch (level) {
14568                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14569                         break; }
14570
14571                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14572                                 {
14573                                         uint32_t _flags_save_string = ndr->flags;
14574                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14575                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14576                                         ndr->flags = _flags_save_string;
14577                                 }
14578                         break; }
14579
14580                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14581                                 {
14582                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14583                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14584                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14585                                         ndr->flags = _flags_save_DATA_BLOB;
14586                                 }
14587                         break; }
14588
14589                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14590                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14591                         break; }
14592
14593                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14594                                 {
14595                                         uint32_t _flags_save_string_array = ndr->flags;
14596                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14597                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14598                                         ndr->flags = _flags_save_string_array;
14599                                 }
14600                         break; }
14601
14602                         default: {
14603                                 {
14604                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14605                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14606                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14607                                         ndr->flags = _flags_save_DATA_BLOB;
14608                                 }
14609                         break; }
14610
14611                 }
14612         }
14613         if (ndr_flags & NDR_BUFFERS) {
14614                 switch (level) {
14615                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14616                         break;
14617
14618                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14619                         break;
14620
14621                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14622                         break;
14623
14624                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14625                         break;
14626
14627                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14628                         break;
14629
14630                         default:
14631                         break;
14632
14633                 }
14634         }
14635         return NDR_ERR_SUCCESS;
14636 }
14637
14638 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14639 {
14640         int level;
14641         level = ndr_print_get_switch_value(ndr, r);
14642         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14643         switch (level) {
14644                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14645                 break;
14646
14647                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14648                         ndr_print_string(ndr, "string", r->string);
14649                 break;
14650
14651                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14652                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14653                 break;
14654
14655                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14656                         ndr_print_uint32(ndr, "value", r->value);
14657                 break;
14658
14659                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14660                         ndr_print_string_array(ndr, "string_array", r->string_array);
14661                 break;
14662
14663                 default:
14664                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14665                 break;
14666
14667         }
14668 }
14669
14670 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14671 {
14672         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14673 }
14674
14675 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14676 {
14677         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14678         return NDR_ERR_SUCCESS;
14679 }
14680
14681 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14682 {
14683         uint32_t v;
14684         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14685         *r = v;
14686         return NDR_ERR_SUCCESS;
14687 }
14688
14689 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14690 {
14691         const char *val = NULL;
14692
14693         switch (r) {
14694                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14695                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14696                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14697         }
14698         ndr_print_enum(ndr, name, "ENUM", val, r);
14699 }
14700
14701 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14702 {
14703         if (ndr_flags & NDR_SCALARS) {
14704                 NDR_CHECK(ndr_push_align(ndr, 4));
14705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14707         }
14708         if (ndr_flags & NDR_BUFFERS) {
14709         }
14710         return NDR_ERR_SUCCESS;
14711 }
14712
14713 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14714 {
14715         if (ndr_flags & NDR_SCALARS) {
14716                 NDR_CHECK(ndr_pull_align(ndr, 4));
14717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14719         }
14720         if (ndr_flags & NDR_BUFFERS) {
14721         }
14722         return NDR_ERR_SUCCESS;
14723 }
14724
14725 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14726 {
14727         ndr_print_struct(ndr, name, "spoolss_FormSize");
14728         ndr->depth++;
14729         ndr_print_uint32(ndr, "width", r->width);
14730         ndr_print_uint32(ndr, "height", r->height);
14731         ndr->depth--;
14732 }
14733
14734 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14735 {
14736         if (ndr_flags & NDR_SCALARS) {
14737                 NDR_CHECK(ndr_push_align(ndr, 4));
14738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14742         }
14743         if (ndr_flags & NDR_BUFFERS) {
14744         }
14745         return NDR_ERR_SUCCESS;
14746 }
14747
14748 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14749 {
14750         if (ndr_flags & NDR_SCALARS) {
14751                 NDR_CHECK(ndr_pull_align(ndr, 4));
14752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14756         }
14757         if (ndr_flags & NDR_BUFFERS) {
14758         }
14759         return NDR_ERR_SUCCESS;
14760 }
14761
14762 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14763 {
14764         ndr_print_struct(ndr, name, "spoolss_FormArea");
14765         ndr->depth++;
14766         ndr_print_uint32(ndr, "left", r->left);
14767         ndr_print_uint32(ndr, "top", r->top);
14768         ndr_print_uint32(ndr, "right", r->right);
14769         ndr_print_uint32(ndr, "bottom", r->bottom);
14770         ndr->depth--;
14771 }
14772
14773 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14774 {
14775         if (ndr_flags & NDR_SCALARS) {
14776                 NDR_CHECK(ndr_push_align(ndr, 4));
14777                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14778                 {
14779                         uint32_t _flags_save_string = ndr->flags;
14780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14782                         ndr->flags = _flags_save_string;
14783                 }
14784                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14785                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14786         }
14787         if (ndr_flags & NDR_BUFFERS) {
14788                 {
14789                         uint32_t _flags_save_string = ndr->flags;
14790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14791                         if (r->form_name) {
14792                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14793                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14794                         }
14795                         ndr->flags = _flags_save_string;
14796                 }
14797         }
14798         return NDR_ERR_SUCCESS;
14799 }
14800
14801 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14802 {
14803         uint32_t _ptr_form_name;
14804         TALLOC_CTX *_mem_save_form_name_0;
14805         if (ndr_flags & NDR_SCALARS) {
14806                 NDR_CHECK(ndr_pull_align(ndr, 4));
14807                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14808                 {
14809                         uint32_t _flags_save_string = ndr->flags;
14810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14812                         if (_ptr_form_name) {
14813                                 NDR_PULL_ALLOC(ndr, r->form_name);
14814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14815                         } else {
14816                                 r->form_name = NULL;
14817                         }
14818                         ndr->flags = _flags_save_string;
14819                 }
14820                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14821                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14822         }
14823         if (ndr_flags & NDR_BUFFERS) {
14824                 {
14825                         uint32_t _flags_save_string = ndr->flags;
14826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14827                         if (r->form_name) {
14828                                 uint32_t _relative_save_offset;
14829                                 _relative_save_offset = ndr->offset;
14830                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14831                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14832                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14833                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14834                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14835                                 ndr->offset = _relative_save_offset;
14836                         }
14837                         ndr->flags = _flags_save_string;
14838                 }
14839         }
14840         return NDR_ERR_SUCCESS;
14841 }
14842
14843 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14844 {
14845         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14846         ndr->depth++;
14847         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14848         ndr_print_ptr(ndr, "form_name", r->form_name);
14849         ndr->depth++;
14850         if (r->form_name) {
14851                 ndr_print_string(ndr, "form_name", r->form_name);
14852         }
14853         ndr->depth--;
14854         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14855         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14856         ndr->depth--;
14857 }
14858
14859 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14860 {
14861         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14862 }
14863
14864 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14865 {
14866         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14867         return NDR_ERR_SUCCESS;
14868 }
14869
14870 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14871 {
14872         uint32_t v;
14873         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14874         *r = v;
14875         return NDR_ERR_SUCCESS;
14876 }
14877
14878 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14879 {
14880         ndr_print_uint32(ndr, name, r);
14881         ndr->depth++;
14882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14885         ndr->depth--;
14886 }
14887
14888 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14889 {
14890         if (ndr_flags & NDR_SCALARS) {
14891                 NDR_CHECK(ndr_push_align(ndr, 4));
14892                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14893                 {
14894                         uint32_t _flags_save_string = ndr->flags;
14895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14896                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14897                         ndr->flags = _flags_save_string;
14898                 }
14899                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14900                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14901                 {
14902                         uint32_t _flags_save_string = ndr->flags;
14903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14904                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14905                         ndr->flags = _flags_save_string;
14906                 }
14907                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14908                 {
14909                         uint32_t _flags_save_string = ndr->flags;
14910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14911                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14912                         ndr->flags = _flags_save_string;
14913                 }
14914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14915                 {
14916                         uint32_t _flags_save_string = ndr->flags;
14917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14918                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14919                         ndr->flags = _flags_save_string;
14920                 }
14921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14922         }
14923         if (ndr_flags & NDR_BUFFERS) {
14924                 {
14925                         uint32_t _flags_save_string = ndr->flags;
14926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14927                         if (r->form_name) {
14928                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14929                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14930                         }
14931                         ndr->flags = _flags_save_string;
14932                 }
14933                 {
14934                         uint32_t _flags_save_string = ndr->flags;
14935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14936                         if (r->keyword) {
14937                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
14938                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
14939                         }
14940                         ndr->flags = _flags_save_string;
14941                 }
14942                 {
14943                         uint32_t _flags_save_string = ndr->flags;
14944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14945                         if (r->mui_dll) {
14946                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
14947                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
14948                         }
14949                         ndr->flags = _flags_save_string;
14950                 }
14951                 {
14952                         uint32_t _flags_save_string = ndr->flags;
14953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14954                         if (r->display_name) {
14955                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
14956                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
14957                         }
14958                         ndr->flags = _flags_save_string;
14959                 }
14960         }
14961         return NDR_ERR_SUCCESS;
14962 }
14963
14964 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
14965 {
14966         uint32_t _ptr_form_name;
14967         TALLOC_CTX *_mem_save_form_name_0;
14968         uint32_t _ptr_keyword;
14969         TALLOC_CTX *_mem_save_keyword_0;
14970         uint32_t _ptr_mui_dll;
14971         TALLOC_CTX *_mem_save_mui_dll_0;
14972         uint32_t _ptr_display_name;
14973         TALLOC_CTX *_mem_save_display_name_0;
14974         if (ndr_flags & NDR_SCALARS) {
14975                 NDR_CHECK(ndr_pull_align(ndr, 4));
14976                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14977                 {
14978                         uint32_t _flags_save_string = ndr->flags;
14979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14980                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14981                         if (_ptr_form_name) {
14982                                 NDR_PULL_ALLOC(ndr, r->form_name);
14983                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14984                         } else {
14985                                 r->form_name = NULL;
14986                         }
14987                         ndr->flags = _flags_save_string;
14988                 }
14989                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14990                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14991                 {
14992                         uint32_t _flags_save_string = ndr->flags;
14993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14994                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
14995                         if (_ptr_keyword) {
14996                                 NDR_PULL_ALLOC(ndr, r->keyword);
14997                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
14998                         } else {
14999                                 r->keyword = NULL;
15000                         }
15001                         ndr->flags = _flags_save_string;
15002                 }
15003                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15004                 {
15005                         uint32_t _flags_save_string = ndr->flags;
15006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15007                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15008                         if (_ptr_mui_dll) {
15009                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15010                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15011                         } else {
15012                                 r->mui_dll = NULL;
15013                         }
15014                         ndr->flags = _flags_save_string;
15015                 }
15016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15017                 {
15018                         uint32_t _flags_save_string = ndr->flags;
15019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15021                         if (_ptr_display_name) {
15022                                 NDR_PULL_ALLOC(ndr, r->display_name);
15023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15024                         } else {
15025                                 r->display_name = NULL;
15026                         }
15027                         ndr->flags = _flags_save_string;
15028                 }
15029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15030         }
15031         if (ndr_flags & NDR_BUFFERS) {
15032                 {
15033                         uint32_t _flags_save_string = ndr->flags;
15034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15035                         if (r->form_name) {
15036                                 uint32_t _relative_save_offset;
15037                                 _relative_save_offset = ndr->offset;
15038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15039                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15040                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15043                                 ndr->offset = _relative_save_offset;
15044                         }
15045                         ndr->flags = _flags_save_string;
15046                 }
15047                 {
15048                         uint32_t _flags_save_string = ndr->flags;
15049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15050                         if (r->keyword) {
15051                                 uint32_t _relative_save_offset;
15052                                 _relative_save_offset = ndr->offset;
15053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15054                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15055                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15058                                 ndr->offset = _relative_save_offset;
15059                         }
15060                         ndr->flags = _flags_save_string;
15061                 }
15062                 {
15063                         uint32_t _flags_save_string = ndr->flags;
15064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15065                         if (r->mui_dll) {
15066                                 uint32_t _relative_save_offset;
15067                                 _relative_save_offset = ndr->offset;
15068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15069                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15070                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15073                                 ndr->offset = _relative_save_offset;
15074                         }
15075                         ndr->flags = _flags_save_string;
15076                 }
15077                 {
15078                         uint32_t _flags_save_string = ndr->flags;
15079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15080                         if (r->display_name) {
15081                                 uint32_t _relative_save_offset;
15082                                 _relative_save_offset = ndr->offset;
15083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15084                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15085                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15086                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15088                                 ndr->offset = _relative_save_offset;
15089                         }
15090                         ndr->flags = _flags_save_string;
15091                 }
15092         }
15093         return NDR_ERR_SUCCESS;
15094 }
15095
15096 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15097 {
15098         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15099         ndr->depth++;
15100         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15101         ndr_print_ptr(ndr, "form_name", r->form_name);
15102         ndr->depth++;
15103         if (r->form_name) {
15104                 ndr_print_string(ndr, "form_name", r->form_name);
15105         }
15106         ndr->depth--;
15107         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15108         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15109         ndr_print_ptr(ndr, "keyword", r->keyword);
15110         ndr->depth++;
15111         if (r->keyword) {
15112                 ndr_print_string(ndr, "keyword", r->keyword);
15113         }
15114         ndr->depth--;
15115         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15116         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15117         ndr->depth++;
15118         if (r->mui_dll) {
15119                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15120         }
15121         ndr->depth--;
15122         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15123         ndr_print_ptr(ndr, "display_name", r->display_name);
15124         ndr->depth++;
15125         if (r->display_name) {
15126                 ndr_print_string(ndr, "display_name", r->display_name);
15127         }
15128         ndr->depth--;
15129         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15130         ndr->depth--;
15131 }
15132
15133 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15134 {
15135         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15136 }
15137
15138 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15139 {
15140         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15141         if (ndr_flags & NDR_SCALARS) {
15142                 int level = ndr_push_get_switch_value(ndr, r);
15143                 switch (level) {
15144                         case 1: {
15145                                 NDR_CHECK(ndr_push_align(ndr, 4));
15146                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15147                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15148                         break; }
15149
15150                         case 2: {
15151                                 NDR_CHECK(ndr_push_align(ndr, 4));
15152                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15153                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15154                         break; }
15155
15156                         default: {
15157                         break; }
15158
15159                 }
15160         }
15161         if (ndr_flags & NDR_BUFFERS) {
15162                 int level = ndr_push_get_switch_value(ndr, r);
15163                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15164                 switch (level) {
15165                         case 1:
15166                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15167                         break;
15168
15169                         case 2:
15170                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15171                         break;
15172
15173                         default:
15174                         break;
15175
15176                 }
15177         }
15178         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15179         return NDR_ERR_SUCCESS;
15180 }
15181
15182 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15183 {
15184         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15185         int level;
15186         level = ndr_pull_get_switch_value(ndr, r);
15187         if (ndr_flags & NDR_SCALARS) {
15188                 switch (level) {
15189                         case 1: {
15190                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15191                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15192                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15193                         break; }
15194
15195                         case 2: {
15196                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15197                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15198                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15199                         break; }
15200
15201                         default: {
15202                         break; }
15203
15204                 }
15205         }
15206         if (ndr_flags & NDR_BUFFERS) {
15207                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15208                 switch (level) {
15209                         case 1:
15210                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15211                         break;
15212
15213                         case 2:
15214                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15215                         break;
15216
15217                         default:
15218                         break;
15219
15220                 }
15221         }
15222         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15223         return NDR_ERR_SUCCESS;
15224 }
15225
15226 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15227 {
15228         int level;
15229         level = ndr_print_get_switch_value(ndr, r);
15230         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15231         switch (level) {
15232                 case 1:
15233                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15234                 break;
15235
15236                 case 2:
15237                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15238                 break;
15239
15240                 default:
15241                 break;
15242
15243         }
15244 }
15245
15246 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15247 {
15248         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15249 }
15250
15251 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15252 {
15253         if (ndr_flags & NDR_SCALARS) {
15254                 NDR_CHECK(ndr_push_align(ndr, 4));
15255                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15257                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15258                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15259         }
15260         if (ndr_flags & NDR_BUFFERS) {
15261                 if (r->form_name) {
15262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15265                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15266                 }
15267         }
15268         return NDR_ERR_SUCCESS;
15269 }
15270
15271 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15272 {
15273         uint32_t _ptr_form_name;
15274         TALLOC_CTX *_mem_save_form_name_0;
15275         if (ndr_flags & NDR_SCALARS) {
15276                 NDR_CHECK(ndr_pull_align(ndr, 4));
15277                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15279                 if (_ptr_form_name) {
15280                         NDR_PULL_ALLOC(ndr, r->form_name);
15281                 } else {
15282                         r->form_name = NULL;
15283                 }
15284                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15285                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15286         }
15287         if (ndr_flags & NDR_BUFFERS) {
15288                 if (r->form_name) {
15289                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15290                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15293                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15294                                 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));
15295                         }
15296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15297                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15299                 }
15300         }
15301         return NDR_ERR_SUCCESS;
15302 }
15303
15304 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15305 {
15306         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15307         ndr->depth++;
15308         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15309         ndr_print_ptr(ndr, "form_name", r->form_name);
15310         ndr->depth++;
15311         if (r->form_name) {
15312                 ndr_print_string(ndr, "form_name", r->form_name);
15313         }
15314         ndr->depth--;
15315         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15316         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15317         ndr->depth--;
15318 }
15319
15320 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15321 {
15322         if (ndr_flags & NDR_SCALARS) {
15323                 NDR_CHECK(ndr_push_align(ndr, 4));
15324                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15326                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15327                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15329                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15334         }
15335         if (ndr_flags & NDR_BUFFERS) {
15336                 if (r->form_name) {
15337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15341                 }
15342                 if (r->keyword) {
15343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15346                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15347                 }
15348                 if (r->mui_dll) {
15349                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15352                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15353                 }
15354                 if (r->display_name) {
15355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15358                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15359                 }
15360         }
15361         return NDR_ERR_SUCCESS;
15362 }
15363
15364 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15365 {
15366         uint32_t _ptr_form_name;
15367         TALLOC_CTX *_mem_save_form_name_0;
15368         uint32_t _ptr_keyword;
15369         TALLOC_CTX *_mem_save_keyword_0;
15370         uint32_t _ptr_mui_dll;
15371         TALLOC_CTX *_mem_save_mui_dll_0;
15372         uint32_t _ptr_display_name;
15373         TALLOC_CTX *_mem_save_display_name_0;
15374         if (ndr_flags & NDR_SCALARS) {
15375                 NDR_CHECK(ndr_pull_align(ndr, 4));
15376                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15378                 if (_ptr_form_name) {
15379                         NDR_PULL_ALLOC(ndr, r->form_name);
15380                 } else {
15381                         r->form_name = NULL;
15382                 }
15383                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15384                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15386                 if (_ptr_keyword) {
15387                         NDR_PULL_ALLOC(ndr, r->keyword);
15388                 } else {
15389                         r->keyword = NULL;
15390                 }
15391                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15393                 if (_ptr_mui_dll) {
15394                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15395                 } else {
15396                         r->mui_dll = NULL;
15397                 }
15398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15399                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15400                 if (_ptr_display_name) {
15401                         NDR_PULL_ALLOC(ndr, r->display_name);
15402                 } else {
15403                         r->display_name = NULL;
15404                 }
15405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15406         }
15407         if (ndr_flags & NDR_BUFFERS) {
15408                 if (r->form_name) {
15409                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15410                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15411                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15412                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15413                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15414                                 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));
15415                         }
15416                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15417                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15418                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15419                 }
15420                 if (r->keyword) {
15421                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15422                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15424                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15425                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15426                                 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));
15427                         }
15428                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15429                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15431                 }
15432                 if (r->mui_dll) {
15433                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15434                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15437                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15438                                 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));
15439                         }
15440                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15441                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15443                 }
15444                 if (r->display_name) {
15445                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15446                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15449                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15450                                 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));
15451                         }
15452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15455                 }
15456         }
15457         return NDR_ERR_SUCCESS;
15458 }
15459
15460 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15461 {
15462         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15463         ndr->depth++;
15464         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15465         ndr_print_ptr(ndr, "form_name", r->form_name);
15466         ndr->depth++;
15467         if (r->form_name) {
15468                 ndr_print_string(ndr, "form_name", r->form_name);
15469         }
15470         ndr->depth--;
15471         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15472         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15473         ndr_print_ptr(ndr, "keyword", r->keyword);
15474         ndr->depth++;
15475         if (r->keyword) {
15476                 ndr_print_string(ndr, "keyword", r->keyword);
15477         }
15478         ndr->depth--;
15479         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15480         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15481         ndr->depth++;
15482         if (r->mui_dll) {
15483                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15484         }
15485         ndr->depth--;
15486         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15487         ndr_print_ptr(ndr, "display_name", r->display_name);
15488         ndr->depth++;
15489         if (r->display_name) {
15490                 ndr_print_string(ndr, "display_name", r->display_name);
15491         }
15492         ndr->depth--;
15493         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15494         ndr->depth--;
15495 }
15496
15497 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15498 {
15499         if (ndr_flags & NDR_SCALARS) {
15500                 int level = ndr_push_get_switch_value(ndr, r);
15501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15502                 switch (level) {
15503                         case 1: {
15504                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15505                         break; }
15506
15507                         case 2: {
15508                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15509                         break; }
15510
15511                         default:
15512                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15513                 }
15514         }
15515         if (ndr_flags & NDR_BUFFERS) {
15516                 int level = ndr_push_get_switch_value(ndr, r);
15517                 switch (level) {
15518                         case 1:
15519                                 if (r->info1) {
15520                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15521                                 }
15522                         break;
15523
15524                         case 2:
15525                                 if (r->info2) {
15526                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15527                                 }
15528                         break;
15529
15530                         default:
15531                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15532                 }
15533         }
15534         return NDR_ERR_SUCCESS;
15535 }
15536
15537 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15538 {
15539         int level;
15540         uint32_t _level;
15541         TALLOC_CTX *_mem_save_info1_0;
15542         TALLOC_CTX *_mem_save_info2_0;
15543         level = ndr_pull_get_switch_value(ndr, r);
15544         if (ndr_flags & NDR_SCALARS) {
15545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15546                 if (_level != level) {
15547                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15548                 }
15549                 switch (level) {
15550                         case 1: {
15551                                 uint32_t _ptr_info1;
15552                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15553                                 if (_ptr_info1) {
15554                                         NDR_PULL_ALLOC(ndr, r->info1);
15555                                 } else {
15556                                         r->info1 = NULL;
15557                                 }
15558                         break; }
15559
15560                         case 2: {
15561                                 uint32_t _ptr_info2;
15562                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15563                                 if (_ptr_info2) {
15564                                         NDR_PULL_ALLOC(ndr, r->info2);
15565                                 } else {
15566                                         r->info2 = NULL;
15567                                 }
15568                         break; }
15569
15570                         default:
15571                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15572                 }
15573         }
15574         if (ndr_flags & NDR_BUFFERS) {
15575                 switch (level) {
15576                         case 1:
15577                                 if (r->info1) {
15578                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15579                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15580                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15581                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15582                                 }
15583                         break;
15584
15585                         case 2:
15586                                 if (r->info2) {
15587                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15588                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15589                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15590                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15591                                 }
15592                         break;
15593
15594                         default:
15595                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15596                 }
15597         }
15598         return NDR_ERR_SUCCESS;
15599 }
15600
15601 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15602 {
15603         int level;
15604         level = ndr_print_get_switch_value(ndr, r);
15605         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15606         switch (level) {
15607                 case 1:
15608                         ndr_print_ptr(ndr, "info1", r->info1);
15609                         ndr->depth++;
15610                         if (r->info1) {
15611                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15612                         }
15613                         ndr->depth--;
15614                 break;
15615
15616                 case 2:
15617                         ndr_print_ptr(ndr, "info2", r->info2);
15618                         ndr->depth++;
15619                         if (r->info2) {
15620                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15621                         }
15622                         ndr->depth--;
15623                 break;
15624
15625                 default:
15626                         ndr_print_bad_level(ndr, name, level);
15627         }
15628 }
15629
15630 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15631 {
15632         if (ndr_flags & NDR_SCALARS) {
15633                 NDR_CHECK(ndr_push_align(ndr, 4));
15634                 {
15635                         uint32_t _flags_save_string = ndr->flags;
15636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15638                         ndr->flags = _flags_save_string;
15639                 }
15640         }
15641         if (ndr_flags & NDR_BUFFERS) {
15642                 {
15643                         uint32_t _flags_save_string = ndr->flags;
15644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15645                         if (r->port_name) {
15646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15648                         }
15649                         ndr->flags = _flags_save_string;
15650                 }
15651         }
15652         return NDR_ERR_SUCCESS;
15653 }
15654
15655 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15656 {
15657         uint32_t _ptr_port_name;
15658         TALLOC_CTX *_mem_save_port_name_0;
15659         if (ndr_flags & NDR_SCALARS) {
15660                 NDR_CHECK(ndr_pull_align(ndr, 4));
15661                 {
15662                         uint32_t _flags_save_string = ndr->flags;
15663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15665                         if (_ptr_port_name) {
15666                                 NDR_PULL_ALLOC(ndr, r->port_name);
15667                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15668                         } else {
15669                                 r->port_name = NULL;
15670                         }
15671                         ndr->flags = _flags_save_string;
15672                 }
15673         }
15674         if (ndr_flags & NDR_BUFFERS) {
15675                 {
15676                         uint32_t _flags_save_string = ndr->flags;
15677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15678                         if (r->port_name) {
15679                                 uint32_t _relative_save_offset;
15680                                 _relative_save_offset = ndr->offset;
15681                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15682                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15683                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15684                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15685                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15686                                 ndr->offset = _relative_save_offset;
15687                         }
15688                         ndr->flags = _flags_save_string;
15689                 }
15690         }
15691         return NDR_ERR_SUCCESS;
15692 }
15693
15694 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15695 {
15696         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15697         ndr->depth++;
15698         ndr_print_ptr(ndr, "port_name", r->port_name);
15699         ndr->depth++;
15700         if (r->port_name) {
15701                 ndr_print_string(ndr, "port_name", r->port_name);
15702         }
15703         ndr->depth--;
15704         ndr->depth--;
15705 }
15706
15707 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15708 {
15709         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15710 }
15711
15712 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15713 {
15714         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15715         return NDR_ERR_SUCCESS;
15716 }
15717
15718 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15719 {
15720         uint32_t v;
15721         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15722         *r = v;
15723         return NDR_ERR_SUCCESS;
15724 }
15725
15726 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15727 {
15728         ndr_print_uint32(ndr, name, r);
15729         ndr->depth++;
15730         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15731         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15732         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15733         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15734         ndr->depth--;
15735 }
15736
15737 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15738 {
15739         if (ndr_flags & NDR_SCALARS) {
15740                 NDR_CHECK(ndr_push_align(ndr, 4));
15741                 {
15742                         uint32_t _flags_save_string = ndr->flags;
15743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15745                         ndr->flags = _flags_save_string;
15746                 }
15747                 {
15748                         uint32_t _flags_save_string = ndr->flags;
15749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15751                         ndr->flags = _flags_save_string;
15752                 }
15753                 {
15754                         uint32_t _flags_save_string = ndr->flags;
15755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15757                         ndr->flags = _flags_save_string;
15758                 }
15759                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15761         }
15762         if (ndr_flags & NDR_BUFFERS) {
15763                 {
15764                         uint32_t _flags_save_string = ndr->flags;
15765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15766                         if (r->port_name) {
15767                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15768                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15769                         }
15770                         ndr->flags = _flags_save_string;
15771                 }
15772                 {
15773                         uint32_t _flags_save_string = ndr->flags;
15774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15775                         if (r->monitor_name) {
15776                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15777                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15778                         }
15779                         ndr->flags = _flags_save_string;
15780                 }
15781                 {
15782                         uint32_t _flags_save_string = ndr->flags;
15783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15784                         if (r->description) {
15785                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15786                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15787                         }
15788                         ndr->flags = _flags_save_string;
15789                 }
15790         }
15791         return NDR_ERR_SUCCESS;
15792 }
15793
15794 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15795 {
15796         uint32_t _ptr_port_name;
15797         TALLOC_CTX *_mem_save_port_name_0;
15798         uint32_t _ptr_monitor_name;
15799         TALLOC_CTX *_mem_save_monitor_name_0;
15800         uint32_t _ptr_description;
15801         TALLOC_CTX *_mem_save_description_0;
15802         if (ndr_flags & NDR_SCALARS) {
15803                 NDR_CHECK(ndr_pull_align(ndr, 4));
15804                 {
15805                         uint32_t _flags_save_string = ndr->flags;
15806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15808                         if (_ptr_port_name) {
15809                                 NDR_PULL_ALLOC(ndr, r->port_name);
15810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15811                         } else {
15812                                 r->port_name = NULL;
15813                         }
15814                         ndr->flags = _flags_save_string;
15815                 }
15816                 {
15817                         uint32_t _flags_save_string = ndr->flags;
15818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15820                         if (_ptr_monitor_name) {
15821                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15823                         } else {
15824                                 r->monitor_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15832                         if (_ptr_description) {
15833                                 NDR_PULL_ALLOC(ndr, r->description);
15834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15835                         } else {
15836                                 r->description = NULL;
15837                         }
15838                         ndr->flags = _flags_save_string;
15839                 }
15840                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15842         }
15843         if (ndr_flags & NDR_BUFFERS) {
15844                 {
15845                         uint32_t _flags_save_string = ndr->flags;
15846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15847                         if (r->port_name) {
15848                                 uint32_t _relative_save_offset;
15849                                 _relative_save_offset = ndr->offset;
15850                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15851                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15852                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15853                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15854                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15855                                 ndr->offset = _relative_save_offset;
15856                         }
15857                         ndr->flags = _flags_save_string;
15858                 }
15859                 {
15860                         uint32_t _flags_save_string = ndr->flags;
15861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15862                         if (r->monitor_name) {
15863                                 uint32_t _relative_save_offset;
15864                                 _relative_save_offset = ndr->offset;
15865                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15866                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15867                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15868                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15869                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15870                                 ndr->offset = _relative_save_offset;
15871                         }
15872                         ndr->flags = _flags_save_string;
15873                 }
15874                 {
15875                         uint32_t _flags_save_string = ndr->flags;
15876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15877                         if (r->description) {
15878                                 uint32_t _relative_save_offset;
15879                                 _relative_save_offset = ndr->offset;
15880                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15881                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15882                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15883                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15884                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15885                                 ndr->offset = _relative_save_offset;
15886                         }
15887                         ndr->flags = _flags_save_string;
15888                 }
15889         }
15890         return NDR_ERR_SUCCESS;
15891 }
15892
15893 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15894 {
15895         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15896         ndr->depth++;
15897         ndr_print_ptr(ndr, "port_name", r->port_name);
15898         ndr->depth++;
15899         if (r->port_name) {
15900                 ndr_print_string(ndr, "port_name", r->port_name);
15901         }
15902         ndr->depth--;
15903         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15904         ndr->depth++;
15905         if (r->monitor_name) {
15906                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15907         }
15908         ndr->depth--;
15909         ndr_print_ptr(ndr, "description", r->description);
15910         ndr->depth++;
15911         if (r->description) {
15912                 ndr_print_string(ndr, "description", r->description);
15913         }
15914         ndr->depth--;
15915         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15916         ndr_print_uint32(ndr, "reserved", r->reserved);
15917         ndr->depth--;
15918 }
15919
15920 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15921 {
15922         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15923 }
15924
15925 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15926 {
15927         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15928         return NDR_ERR_SUCCESS;
15929 }
15930
15931 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
15932 {
15933         uint32_t v;
15934         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15935         *r = v;
15936         return NDR_ERR_SUCCESS;
15937 }
15938
15939 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
15940 {
15941         const char *val = NULL;
15942
15943         switch (r) {
15944                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
15945                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
15946                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
15947                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
15948                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
15949                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
15950                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
15951                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
15952                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
15953                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
15954                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
15955                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
15956                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
15957         }
15958         ndr_print_enum(ndr, name, "ENUM", val, r);
15959 }
15960
15961 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
15962 {
15963         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15964         return NDR_ERR_SUCCESS;
15965 }
15966
15967 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
15968 {
15969         uint32_t v;
15970         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15971         *r = v;
15972         return NDR_ERR_SUCCESS;
15973 }
15974
15975 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
15976 {
15977         const char *val = NULL;
15978
15979         switch (r) {
15980                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
15981                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
15982                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
15983         }
15984         ndr_print_enum(ndr, name, "ENUM", val, r);
15985 }
15986
15987 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
15988 {
15989         if (ndr_flags & NDR_SCALARS) {
15990                 NDR_CHECK(ndr_push_align(ndr, 4));
15991                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
15992                 {
15993                         uint32_t _flags_save_string = ndr->flags;
15994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
15996                         ndr->flags = _flags_save_string;
15997                 }
15998                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
15999         }
16000         if (ndr_flags & NDR_BUFFERS) {
16001                 {
16002                         uint32_t _flags_save_string = ndr->flags;
16003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16004                         if (r->status_string) {
16005                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16007                         }
16008                         ndr->flags = _flags_save_string;
16009                 }
16010         }
16011         return NDR_ERR_SUCCESS;
16012 }
16013
16014 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16015 {
16016         uint32_t _ptr_status_string;
16017         TALLOC_CTX *_mem_save_status_string_0;
16018         if (ndr_flags & NDR_SCALARS) {
16019                 NDR_CHECK(ndr_pull_align(ndr, 4));
16020                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16021                 {
16022                         uint32_t _flags_save_string = ndr->flags;
16023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16025                         if (_ptr_status_string) {
16026                                 NDR_PULL_ALLOC(ndr, r->status_string);
16027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16028                         } else {
16029                                 r->status_string = NULL;
16030                         }
16031                         ndr->flags = _flags_save_string;
16032                 }
16033                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16034         }
16035         if (ndr_flags & NDR_BUFFERS) {
16036                 {
16037                         uint32_t _flags_save_string = ndr->flags;
16038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16039                         if (r->status_string) {
16040                                 uint32_t _relative_save_offset;
16041                                 _relative_save_offset = ndr->offset;
16042                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16043                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16044                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16045                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16046                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16047                                 ndr->offset = _relative_save_offset;
16048                         }
16049                         ndr->flags = _flags_save_string;
16050                 }
16051         }
16052         return NDR_ERR_SUCCESS;
16053 }
16054
16055 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16056 {
16057         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16058         ndr->depth++;
16059         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16060         ndr_print_ptr(ndr, "status_string", r->status_string);
16061         ndr->depth++;
16062         if (r->status_string) {
16063                 ndr_print_string(ndr, "status_string", r->status_string);
16064         }
16065         ndr->depth--;
16066         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16067         ndr->depth--;
16068 }
16069
16070 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16071 {
16072         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16073 }
16074
16075 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16076 {
16077         if (ndr_flags & NDR_SCALARS) {
16078                 NDR_CHECK(ndr_push_align(ndr, 4));
16079                 {
16080                         uint32_t _flags_save_string = ndr->flags;
16081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16082                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16083                         ndr->flags = _flags_save_string;
16084                 }
16085                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16086         }
16087         if (ndr_flags & NDR_BUFFERS) {
16088                 {
16089                         uint32_t _flags_save_string = ndr->flags;
16090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16091                         if (r->port_name) {
16092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16094                         }
16095                         ndr->flags = _flags_save_string;
16096                 }
16097         }
16098         return NDR_ERR_SUCCESS;
16099 }
16100
16101 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16102 {
16103         uint32_t _ptr_port_name;
16104         TALLOC_CTX *_mem_save_port_name_0;
16105         if (ndr_flags & NDR_SCALARS) {
16106                 NDR_CHECK(ndr_pull_align(ndr, 4));
16107                 {
16108                         uint32_t _flags_save_string = ndr->flags;
16109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16110                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16111                         if (_ptr_port_name) {
16112                                 NDR_PULL_ALLOC(ndr, r->port_name);
16113                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16114                         } else {
16115                                 r->port_name = NULL;
16116                         }
16117                         ndr->flags = _flags_save_string;
16118                 }
16119                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16120         }
16121         if (ndr_flags & NDR_BUFFERS) {
16122                 {
16123                         uint32_t _flags_save_string = ndr->flags;
16124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16125                         if (r->port_name) {
16126                                 uint32_t _relative_save_offset;
16127                                 _relative_save_offset = ndr->offset;
16128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16129                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16130                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16133                                 ndr->offset = _relative_save_offset;
16134                         }
16135                         ndr->flags = _flags_save_string;
16136                 }
16137         }
16138         return NDR_ERR_SUCCESS;
16139 }
16140
16141 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16142 {
16143         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16144         ndr->depth++;
16145         ndr_print_ptr(ndr, "port_name", r->port_name);
16146         ndr->depth++;
16147         if (r->port_name) {
16148                 ndr_print_string(ndr, "port_name", r->port_name);
16149         }
16150         ndr->depth--;
16151         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16152         ndr->depth--;
16153 }
16154
16155 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16156 {
16157         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16158 }
16159
16160 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16161 {
16162         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16163         if (ndr_flags & NDR_SCALARS) {
16164                 int level = ndr_push_get_switch_value(ndr, r);
16165                 switch (level) {
16166                         case 1: {
16167                                 NDR_CHECK(ndr_push_align(ndr, 4));
16168                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16169                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16170                         break; }
16171
16172                         case 2: {
16173                                 NDR_CHECK(ndr_push_align(ndr, 4));
16174                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16175                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16176                         break; }
16177
16178                         case 3: {
16179                                 NDR_CHECK(ndr_push_align(ndr, 4));
16180                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16181                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16182                         break; }
16183
16184                         case 0xff: {
16185                                 NDR_CHECK(ndr_push_align(ndr, 4));
16186                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16187                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16188                         break; }
16189
16190                         default: {
16191                         break; }
16192
16193                 }
16194         }
16195         if (ndr_flags & NDR_BUFFERS) {
16196                 int level = ndr_push_get_switch_value(ndr, r);
16197                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16198                 switch (level) {
16199                         case 1:
16200                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16201                         break;
16202
16203                         case 2:
16204                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16205                         break;
16206
16207                         case 3:
16208                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16209                         break;
16210
16211                         case 0xff:
16212                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16213                         break;
16214
16215                         default:
16216                         break;
16217
16218                 }
16219         }
16220         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16221         return NDR_ERR_SUCCESS;
16222 }
16223
16224 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16225 {
16226         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16227         int level;
16228         level = ndr_pull_get_switch_value(ndr, r);
16229         if (ndr_flags & NDR_SCALARS) {
16230                 switch (level) {
16231                         case 1: {
16232                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16233                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16234                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16235                         break; }
16236
16237                         case 2: {
16238                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16239                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16240                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16241                         break; }
16242
16243                         case 3: {
16244                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16245                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16246                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16247                         break; }
16248
16249                         case 0xff: {
16250                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16251                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16252                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16253                         break; }
16254
16255                         default: {
16256                         break; }
16257
16258                 }
16259         }
16260         if (ndr_flags & NDR_BUFFERS) {
16261                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16262                 switch (level) {
16263                         case 1:
16264                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16265                         break;
16266
16267                         case 2:
16268                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16269                         break;
16270
16271                         case 3:
16272                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16273                         break;
16274
16275                         case 0xff:
16276                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16277                         break;
16278
16279                         default:
16280                         break;
16281
16282                 }
16283         }
16284         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16285         return NDR_ERR_SUCCESS;
16286 }
16287
16288 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16289 {
16290         int level;
16291         level = ndr_print_get_switch_value(ndr, r);
16292         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16293         switch (level) {
16294                 case 1:
16295                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16296                 break;
16297
16298                 case 2:
16299                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16300                 break;
16301
16302                 case 3:
16303                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16304                 break;
16305
16306                 case 0xff:
16307                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16308                 break;
16309
16310                 default:
16311                 break;
16312
16313         }
16314 }
16315
16316 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16317 {
16318         if (ndr_flags & NDR_SCALARS) {
16319                 NDR_CHECK(ndr_push_align(ndr, 4));
16320                 {
16321                         uint32_t _flags_save_string = ndr->flags;
16322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16323                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16324                         ndr->flags = _flags_save_string;
16325                 }
16326         }
16327         if (ndr_flags & NDR_BUFFERS) {
16328                 {
16329                         uint32_t _flags_save_string = ndr->flags;
16330                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16331                         if (r->monitor_name) {
16332                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16333                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16334                         }
16335                         ndr->flags = _flags_save_string;
16336                 }
16337         }
16338         return NDR_ERR_SUCCESS;
16339 }
16340
16341 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16342 {
16343         uint32_t _ptr_monitor_name;
16344         TALLOC_CTX *_mem_save_monitor_name_0;
16345         if (ndr_flags & NDR_SCALARS) {
16346                 NDR_CHECK(ndr_pull_align(ndr, 4));
16347                 {
16348                         uint32_t _flags_save_string = ndr->flags;
16349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16350                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16351                         if (_ptr_monitor_name) {
16352                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16353                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16354                         } else {
16355                                 r->monitor_name = NULL;
16356                         }
16357                         ndr->flags = _flags_save_string;
16358                 }
16359         }
16360         if (ndr_flags & NDR_BUFFERS) {
16361                 {
16362                         uint32_t _flags_save_string = ndr->flags;
16363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16364                         if (r->monitor_name) {
16365                                 uint32_t _relative_save_offset;
16366                                 _relative_save_offset = ndr->offset;
16367                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16368                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16369                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16370                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16371                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16372                                 ndr->offset = _relative_save_offset;
16373                         }
16374                         ndr->flags = _flags_save_string;
16375                 }
16376         }
16377         return NDR_ERR_SUCCESS;
16378 }
16379
16380 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16381 {
16382         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16383         ndr->depth++;
16384         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16385         ndr->depth++;
16386         if (r->monitor_name) {
16387                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16388         }
16389         ndr->depth--;
16390         ndr->depth--;
16391 }
16392
16393 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16394 {
16395         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16396 }
16397
16398 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16399 {
16400         if (ndr_flags & NDR_SCALARS) {
16401                 NDR_CHECK(ndr_push_align(ndr, 4));
16402                 {
16403                         uint32_t _flags_save_string = ndr->flags;
16404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16405                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16406                         ndr->flags = _flags_save_string;
16407                 }
16408                 {
16409                         uint32_t _flags_save_string = ndr->flags;
16410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16411                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16412                         ndr->flags = _flags_save_string;
16413                 }
16414                 {
16415                         uint32_t _flags_save_string = ndr->flags;
16416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16417                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16418                         ndr->flags = _flags_save_string;
16419                 }
16420         }
16421         if (ndr_flags & NDR_BUFFERS) {
16422                 {
16423                         uint32_t _flags_save_string = ndr->flags;
16424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16425                         if (r->monitor_name) {
16426                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16427                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16428                         }
16429                         ndr->flags = _flags_save_string;
16430                 }
16431                 {
16432                         uint32_t _flags_save_string = ndr->flags;
16433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16434                         if (r->environment) {
16435                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16436                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16437                         }
16438                         ndr->flags = _flags_save_string;
16439                 }
16440                 {
16441                         uint32_t _flags_save_string = ndr->flags;
16442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16443                         if (r->dll_name) {
16444                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16445                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16446                         }
16447                         ndr->flags = _flags_save_string;
16448                 }
16449         }
16450         return NDR_ERR_SUCCESS;
16451 }
16452
16453 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16454 {
16455         uint32_t _ptr_monitor_name;
16456         TALLOC_CTX *_mem_save_monitor_name_0;
16457         uint32_t _ptr_environment;
16458         TALLOC_CTX *_mem_save_environment_0;
16459         uint32_t _ptr_dll_name;
16460         TALLOC_CTX *_mem_save_dll_name_0;
16461         if (ndr_flags & NDR_SCALARS) {
16462                 NDR_CHECK(ndr_pull_align(ndr, 4));
16463                 {
16464                         uint32_t _flags_save_string = ndr->flags;
16465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16466                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16467                         if (_ptr_monitor_name) {
16468                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16469                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16470                         } else {
16471                                 r->monitor_name = NULL;
16472                         }
16473                         ndr->flags = _flags_save_string;
16474                 }
16475                 {
16476                         uint32_t _flags_save_string = ndr->flags;
16477                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16478                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16479                         if (_ptr_environment) {
16480                                 NDR_PULL_ALLOC(ndr, r->environment);
16481                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16482                         } else {
16483                                 r->environment = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16491                         if (_ptr_dll_name) {
16492                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16493                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16494                         } else {
16495                                 r->dll_name = NULL;
16496                         }
16497                         ndr->flags = _flags_save_string;
16498                 }
16499         }
16500         if (ndr_flags & NDR_BUFFERS) {
16501                 {
16502                         uint32_t _flags_save_string = ndr->flags;
16503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16504                         if (r->monitor_name) {
16505                                 uint32_t _relative_save_offset;
16506                                 _relative_save_offset = ndr->offset;
16507                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16508                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16509                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16510                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16511                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16512                                 ndr->offset = _relative_save_offset;
16513                         }
16514                         ndr->flags = _flags_save_string;
16515                 }
16516                 {
16517                         uint32_t _flags_save_string = ndr->flags;
16518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16519                         if (r->environment) {
16520                                 uint32_t _relative_save_offset;
16521                                 _relative_save_offset = ndr->offset;
16522                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16523                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16524                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16525                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16526                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16527                                 ndr->offset = _relative_save_offset;
16528                         }
16529                         ndr->flags = _flags_save_string;
16530                 }
16531                 {
16532                         uint32_t _flags_save_string = ndr->flags;
16533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16534                         if (r->dll_name) {
16535                                 uint32_t _relative_save_offset;
16536                                 _relative_save_offset = ndr->offset;
16537                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16538                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16539                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16540                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16541                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16542                                 ndr->offset = _relative_save_offset;
16543                         }
16544                         ndr->flags = _flags_save_string;
16545                 }
16546         }
16547         return NDR_ERR_SUCCESS;
16548 }
16549
16550 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16551 {
16552         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16553         ndr->depth++;
16554         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16555         ndr->depth++;
16556         if (r->monitor_name) {
16557                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16558         }
16559         ndr->depth--;
16560         ndr_print_ptr(ndr, "environment", r->environment);
16561         ndr->depth++;
16562         if (r->environment) {
16563                 ndr_print_string(ndr, "environment", r->environment);
16564         }
16565         ndr->depth--;
16566         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16567         ndr->depth++;
16568         if (r->dll_name) {
16569                 ndr_print_string(ndr, "dll_name", r->dll_name);
16570         }
16571         ndr->depth--;
16572         ndr->depth--;
16573 }
16574
16575 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16576 {
16577         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16578 }
16579
16580 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16581 {
16582         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16583         if (ndr_flags & NDR_SCALARS) {
16584                 int level = ndr_push_get_switch_value(ndr, r);
16585                 switch (level) {
16586                         case 1: {
16587                                 NDR_CHECK(ndr_push_align(ndr, 4));
16588                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16589                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16590                         break; }
16591
16592                         case 2: {
16593                                 NDR_CHECK(ndr_push_align(ndr, 4));
16594                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16595                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16596                         break; }
16597
16598                         default: {
16599                         break; }
16600
16601                 }
16602         }
16603         if (ndr_flags & NDR_BUFFERS) {
16604                 int level = ndr_push_get_switch_value(ndr, r);
16605                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16606                 switch (level) {
16607                         case 1:
16608                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16609                         break;
16610
16611                         case 2:
16612                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16613                         break;
16614
16615                         default:
16616                         break;
16617
16618                 }
16619         }
16620         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16621         return NDR_ERR_SUCCESS;
16622 }
16623
16624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16625 {
16626         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16627         int level;
16628         level = ndr_pull_get_switch_value(ndr, r);
16629         if (ndr_flags & NDR_SCALARS) {
16630                 switch (level) {
16631                         case 1: {
16632                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16633                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16634                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16635                         break; }
16636
16637                         case 2: {
16638                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16639                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16640                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16641                         break; }
16642
16643                         default: {
16644                         break; }
16645
16646                 }
16647         }
16648         if (ndr_flags & NDR_BUFFERS) {
16649                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16650                 switch (level) {
16651                         case 1:
16652                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16653                         break;
16654
16655                         case 2:
16656                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16657                         break;
16658
16659                         default:
16660                         break;
16661
16662                 }
16663         }
16664         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16665         return NDR_ERR_SUCCESS;
16666 }
16667
16668 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16669 {
16670         int level;
16671         level = ndr_print_get_switch_value(ndr, r);
16672         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16673         switch (level) {
16674                 case 1:
16675                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16676                 break;
16677
16678                 case 2:
16679                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16680                 break;
16681
16682                 default:
16683                 break;
16684
16685         }
16686 }
16687
16688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16689 {
16690         if (ndr_flags & NDR_SCALARS) {
16691                 NDR_CHECK(ndr_push_align(ndr, 4));
16692                 {
16693                         uint32_t _flags_save_string = ndr->flags;
16694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16695                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16696                         ndr->flags = _flags_save_string;
16697                 }
16698         }
16699         if (ndr_flags & NDR_BUFFERS) {
16700                 {
16701                         uint32_t _flags_save_string = ndr->flags;
16702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16703                         if (r->name_array) {
16704                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16705                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16706                         }
16707                         ndr->flags = _flags_save_string;
16708                 }
16709         }
16710         return NDR_ERR_SUCCESS;
16711 }
16712
16713 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16714 {
16715         uint32_t _ptr_name_array;
16716         TALLOC_CTX *_mem_save_name_array_0;
16717         if (ndr_flags & NDR_SCALARS) {
16718                 NDR_CHECK(ndr_pull_align(ndr, 4));
16719                 {
16720                         uint32_t _flags_save_string = ndr->flags;
16721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16722                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16723                         if (_ptr_name_array) {
16724                                 NDR_PULL_ALLOC(ndr, r->name_array);
16725                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16726                         } else {
16727                                 r->name_array = NULL;
16728                         }
16729                         ndr->flags = _flags_save_string;
16730                 }
16731         }
16732         if (ndr_flags & NDR_BUFFERS) {
16733                 {
16734                         uint32_t _flags_save_string = ndr->flags;
16735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16736                         if (r->name_array) {
16737                                 uint32_t _relative_save_offset;
16738                                 _relative_save_offset = ndr->offset;
16739                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16740                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16741                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16742                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16743                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16744                                 ndr->offset = _relative_save_offset;
16745                         }
16746                         ndr->flags = _flags_save_string;
16747                 }
16748         }
16749         return NDR_ERR_SUCCESS;
16750 }
16751
16752 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16753 {
16754         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16755         ndr->depth++;
16756         ndr_print_ptr(ndr, "name_array", r->name_array);
16757         ndr->depth++;
16758         if (r->name_array) {
16759                 ndr_print_string(ndr, "name_array", r->name_array);
16760         }
16761         ndr->depth--;
16762         ndr->depth--;
16763 }
16764
16765 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16766 {
16767         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16768 }
16769
16770 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16771 {
16772         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16773         if (ndr_flags & NDR_SCALARS) {
16774                 int level = ndr_push_get_switch_value(ndr, r);
16775                 switch (level) {
16776                         case 1: {
16777                                 NDR_CHECK(ndr_push_align(ndr, 4));
16778                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16779                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16780                         break; }
16781
16782                         default: {
16783                         break; }
16784
16785                 }
16786         }
16787         if (ndr_flags & NDR_BUFFERS) {
16788                 int level = ndr_push_get_switch_value(ndr, r);
16789                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16790                 switch (level) {
16791                         case 1:
16792                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16793                         break;
16794
16795                         default:
16796                         break;
16797
16798                 }
16799         }
16800         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16801         return NDR_ERR_SUCCESS;
16802 }
16803
16804 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16805 {
16806         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16807         int level;
16808         level = ndr_pull_get_switch_value(ndr, r);
16809         if (ndr_flags & NDR_SCALARS) {
16810                 switch (level) {
16811                         case 1: {
16812                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16813                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16814                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16815                         break; }
16816
16817                         default: {
16818                         break; }
16819
16820                 }
16821         }
16822         if (ndr_flags & NDR_BUFFERS) {
16823                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16824                 switch (level) {
16825                         case 1:
16826                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16827                         break;
16828
16829                         default:
16830                         break;
16831
16832                 }
16833         }
16834         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16835         return NDR_ERR_SUCCESS;
16836 }
16837
16838 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16839 {
16840         int level;
16841         level = ndr_print_get_switch_value(ndr, r);
16842         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16843         switch (level) {
16844                 case 1:
16845                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16846                 break;
16847
16848                 default:
16849                 break;
16850
16851         }
16852 }
16853
16854 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16855 {
16856         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16857         return NDR_ERR_SUCCESS;
16858 }
16859
16860 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16861 {
16862         uint32_t v;
16863         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16864         *r = v;
16865         return NDR_ERR_SUCCESS;
16866 }
16867
16868 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16869 {
16870         ndr_print_uint32(ndr, name, r);
16871         ndr->depth++;
16872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16888         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16889         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16890         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16891         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16892         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16893         ndr->depth--;
16894 }
16895
16896 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16897 {
16898         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16899         return NDR_ERR_SUCCESS;
16900 }
16901
16902 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16903 {
16904         uint16_t v;
16905         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16906         *r = v;
16907         return NDR_ERR_SUCCESS;
16908 }
16909
16910 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16911 {
16912         const char *val = NULL;
16913
16914         switch (r) {
16915                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16916                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16917                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16918                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16919                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16920                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16921                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16922                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16923                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16924                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16925                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16926                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16927                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16928                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
16929                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
16930                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
16931                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
16932                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
16933                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
16934                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
16935                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
16936                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
16937                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
16938                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
16939                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
16940                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
16941         }
16942         ndr_print_enum(ndr, name, "ENUM", val, r);
16943 }
16944
16945 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
16946 {
16947         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16948         return NDR_ERR_SUCCESS;
16949 }
16950
16951 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
16952 {
16953         uint16_t v;
16954         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16955         *r = v;
16956         return NDR_ERR_SUCCESS;
16957 }
16958
16959 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
16960 {
16961         const char *val = NULL;
16962
16963         switch (r) {
16964                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
16965                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
16966         }
16967         ndr_print_enum(ndr, name, "ENUM", val, r);
16968 }
16969
16970 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
16971 {
16972         uint32_t cntr_fields_1;
16973         if (ndr_flags & NDR_SCALARS) {
16974                 NDR_CHECK(ndr_push_align(ndr, 4));
16975                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
16976                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
16977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
16978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
16979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
16981         }
16982         if (ndr_flags & NDR_BUFFERS) {
16983                 if (r->fields) {
16984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16985                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
16986                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
16987                         }
16988                 }
16989         }
16990         return NDR_ERR_SUCCESS;
16991 }
16992
16993 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
16994 {
16995         uint32_t _ptr_fields;
16996         uint32_t cntr_fields_1;
16997         TALLOC_CTX *_mem_save_fields_0;
16998         TALLOC_CTX *_mem_save_fields_1;
16999         if (ndr_flags & NDR_SCALARS) {
17000                 NDR_CHECK(ndr_pull_align(ndr, 4));
17001                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17002                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17007                 if (_ptr_fields) {
17008                         NDR_PULL_ALLOC(ndr, r->fields);
17009                 } else {
17010                         r->fields = NULL;
17011                 }
17012         }
17013         if (ndr_flags & NDR_BUFFERS) {
17014                 if (r->fields) {
17015                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17016                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17017                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17018                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17019                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17020                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17021                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17022                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17023                         }
17024                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17026                 }
17027                 if (r->fields) {
17028                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17029                 }
17030         }
17031         return NDR_ERR_SUCCESS;
17032 }
17033
17034 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17035 {
17036         uint32_t cntr_fields_1;
17037         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17038         ndr->depth++;
17039         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17040         ndr_print_uint16(ndr, "u1", r->u1);
17041         ndr_print_uint32(ndr, "u2", r->u2);
17042         ndr_print_uint32(ndr, "u3", r->u3);
17043         ndr_print_uint32(ndr, "count", r->count);
17044         ndr_print_ptr(ndr, "fields", r->fields);
17045         ndr->depth++;
17046         if (r->fields) {
17047                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17048                 ndr->depth++;
17049                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17050                         char *idx_1=NULL;
17051                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17052                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17053                                 free(idx_1);
17054                         }
17055                 }
17056                 ndr->depth--;
17057         }
17058         ndr->depth--;
17059         ndr->depth--;
17060 }
17061
17062 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17063 {
17064         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17065         return NDR_ERR_SUCCESS;
17066 }
17067
17068 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17069 {
17070         uint32_t v;
17071         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17072         *r = v;
17073         return NDR_ERR_SUCCESS;
17074 }
17075
17076 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17077 {
17078         ndr_print_uint32(ndr, name, r);
17079         ndr->depth++;
17080         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17081         ndr->depth--;
17082 }
17083
17084 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17085 {
17086         uint32_t cntr_types_1;
17087         if (ndr_flags & NDR_SCALARS) {
17088                 NDR_CHECK(ndr_push_align(ndr, 4));
17089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17090                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17093         }
17094         if (ndr_flags & NDR_BUFFERS) {
17095                 if (r->types) {
17096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17097                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17098                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17099                         }
17100                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17101                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17102                         }
17103                 }
17104         }
17105         return NDR_ERR_SUCCESS;
17106 }
17107
17108 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17109 {
17110         uint32_t _ptr_types;
17111         uint32_t cntr_types_1;
17112         TALLOC_CTX *_mem_save_types_0;
17113         TALLOC_CTX *_mem_save_types_1;
17114         if (ndr_flags & NDR_SCALARS) {
17115                 NDR_CHECK(ndr_pull_align(ndr, 4));
17116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17117                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17120                 if (_ptr_types) {
17121                         NDR_PULL_ALLOC(ndr, r->types);
17122                 } else {
17123                         r->types = NULL;
17124                 }
17125         }
17126         if (ndr_flags & NDR_BUFFERS) {
17127                 if (r->types) {
17128                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17129                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17130                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17131                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17132                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17133                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17134                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17135                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17136                         }
17137                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17138                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17139                         }
17140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17142                 }
17143                 if (r->types) {
17144                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17145                 }
17146         }
17147         return NDR_ERR_SUCCESS;
17148 }
17149
17150 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17151 {
17152         uint32_t cntr_types_1;
17153         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17154         ndr->depth++;
17155         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17156         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17157         ndr_print_uint32(ndr, "count", r->count);
17158         ndr_print_ptr(ndr, "types", r->types);
17159         ndr->depth++;
17160         if (r->types) {
17161                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17162                 ndr->depth++;
17163                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17164                         char *idx_1=NULL;
17165                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17166                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17167                                 free(idx_1);
17168                         }
17169                 }
17170                 ndr->depth--;
17171         }
17172         ndr->depth--;
17173         ndr->depth--;
17174 }
17175
17176 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17177 {
17178         if (ndr_flags & NDR_SCALARS) {
17179                 NDR_CHECK(ndr_push_align(ndr, 4));
17180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17182         }
17183         if (ndr_flags & NDR_BUFFERS) {
17184                 if (r->string) {
17185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17187                 }
17188         }
17189         return NDR_ERR_SUCCESS;
17190 }
17191
17192 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17193 {
17194         uint32_t _ptr_string;
17195         TALLOC_CTX *_mem_save_string_0;
17196         if (ndr_flags & NDR_SCALARS) {
17197                 NDR_CHECK(ndr_pull_align(ndr, 4));
17198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17200                 if (_ptr_string) {
17201                         NDR_PULL_ALLOC(ndr, r->string);
17202                 } else {
17203                         r->string = NULL;
17204                 }
17205         }
17206         if (ndr_flags & NDR_BUFFERS) {
17207                 if (r->string) {
17208                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17209                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17213                 }
17214                 if (r->string) {
17215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17216                 }
17217         }
17218         return NDR_ERR_SUCCESS;
17219 }
17220
17221 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17222 {
17223         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17224         ndr->depth++;
17225         ndr_print_uint32(ndr, "size", r->size);
17226         ndr_print_ptr(ndr, "string", r->string);
17227         ndr->depth++;
17228         if (r->string) {
17229                 ndr_print_string(ndr, "string", r->string);
17230         }
17231         ndr->depth--;
17232         ndr->depth--;
17233 }
17234
17235 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17236 {
17237         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17238         return NDR_ERR_SUCCESS;
17239 }
17240
17241 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17242 {
17243         uint32_t v;
17244         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17245         *r = v;
17246         return NDR_ERR_SUCCESS;
17247 }
17248
17249 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17250 {
17251         const char *val = NULL;
17252
17253         switch (r) {
17254                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17255                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17256                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17257                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17258                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17259         }
17260         ndr_print_enum(ndr, name, "ENUM", val, r);
17261 }
17262
17263 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17264 {
17265         if (ndr_flags & NDR_SCALARS) {
17266                 int level = ndr_push_get_switch_value(ndr, r);
17267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17268                 switch (level) {
17269                         case 1: {
17270                                 uint32_t cntr_integer_0;
17271                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17272                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17273                                 }
17274                         break; }
17275
17276                         case 2: {
17277                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17278                         break; }
17279
17280                         case 3: {
17281                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17282                         break; }
17283
17284                         case 4: {
17285                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17286                         break; }
17287
17288                         case 5: {
17289                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17290                         break; }
17291
17292                         default:
17293                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17294                 }
17295         }
17296         if (ndr_flags & NDR_BUFFERS) {
17297                 int level = ndr_push_get_switch_value(ndr, r);
17298                 switch (level) {
17299                         case 1:
17300                         break;
17301
17302                         case 2:
17303                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17304                         break;
17305
17306                         case 3:
17307                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17308                         break;
17309
17310                         case 4:
17311                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17312                         break;
17313
17314                         case 5:
17315                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17316                         break;
17317
17318                         default:
17319                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17320                 }
17321         }
17322         return NDR_ERR_SUCCESS;
17323 }
17324
17325 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17326 {
17327         int level;
17328         uint32_t _level;
17329         level = ndr_pull_get_switch_value(ndr, r);
17330         if (ndr_flags & NDR_SCALARS) {
17331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17332                 if (_level != level) {
17333                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17334                 }
17335                 switch (level) {
17336                         case 1: {
17337                                 uint32_t cntr_integer_0;
17338                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17339                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17340                                 }
17341                         break; }
17342
17343                         case 2: {
17344                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17345                         break; }
17346
17347                         case 3: {
17348                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17349                         break; }
17350
17351                         case 4: {
17352                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17353                         break; }
17354
17355                         case 5: {
17356                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17357                         break; }
17358
17359                         default:
17360                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17361                 }
17362         }
17363         if (ndr_flags & NDR_BUFFERS) {
17364                 switch (level) {
17365                         case 1:
17366                         break;
17367
17368                         case 2:
17369                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17370                         break;
17371
17372                         case 3:
17373                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17374                         break;
17375
17376                         case 4:
17377                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17378                         break;
17379
17380                         case 5:
17381                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17382                         break;
17383
17384                         default:
17385                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17386                 }
17387         }
17388         return NDR_ERR_SUCCESS;
17389 }
17390
17391 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17392 {
17393         int level;
17394         uint32_t cntr_integer_0;
17395         level = ndr_print_get_switch_value(ndr, r);
17396         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17397         switch (level) {
17398                 case 1:
17399                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17400                         ndr->depth++;
17401                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17402                                 char *idx_0=NULL;
17403                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17404                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17405                                         free(idx_0);
17406                                 }
17407                         }
17408                         ndr->depth--;
17409                 break;
17410
17411                 case 2:
17412                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17413                 break;
17414
17415                 case 3:
17416                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17417                 break;
17418
17419                 case 4:
17420                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17421                 break;
17422
17423                 case 5:
17424                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17425                 break;
17426
17427                 default:
17428                         ndr_print_bad_level(ndr, name, level);
17429         }
17430 }
17431
17432 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17433 {
17434         if (ndr_flags & NDR_SCALARS) {
17435                 NDR_CHECK(ndr_push_align(ndr, 4));
17436                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17437                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17438                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17440                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17441                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17442         }
17443         if (ndr_flags & NDR_BUFFERS) {
17444                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17445         }
17446         return NDR_ERR_SUCCESS;
17447 }
17448
17449 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17450 {
17451         if (ndr_flags & NDR_SCALARS) {
17452                 NDR_CHECK(ndr_pull_align(ndr, 4));
17453                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17454                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17455                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17457                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17458                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17459         }
17460         if (ndr_flags & NDR_BUFFERS) {
17461                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17462         }
17463         return NDR_ERR_SUCCESS;
17464 }
17465
17466 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17467 {
17468         ndr_print_struct(ndr, name, "spoolss_Notify");
17469         ndr->depth++;
17470         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17471         ndr_print_spoolss_Field(ndr, "field", r->field);
17472         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17473         ndr_print_uint32(ndr, "job_id", r->job_id);
17474         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17475         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17476         ndr->depth--;
17477 }
17478
17479 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17480 {
17481         uint32_t cntr_notifies_0;
17482         if (ndr_flags & NDR_SCALARS) {
17483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17484                 NDR_CHECK(ndr_push_align(ndr, 4));
17485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17488                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17489                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17490                 }
17491         }
17492         if (ndr_flags & NDR_BUFFERS) {
17493                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17494                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17495                 }
17496         }
17497         return NDR_ERR_SUCCESS;
17498 }
17499
17500 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17501 {
17502         uint32_t cntr_notifies_0;
17503         TALLOC_CTX *_mem_save_notifies_0;
17504         if (ndr_flags & NDR_SCALARS) {
17505                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17506                 NDR_CHECK(ndr_pull_align(ndr, 4));
17507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17510                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17511                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17512                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17513                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17514                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17515                 }
17516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17517                 if (r->notifies) {
17518                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17519                 }
17520         }
17521         if (ndr_flags & NDR_BUFFERS) {
17522                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17523                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17524                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17525                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17526                 }
17527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17528         }
17529         return NDR_ERR_SUCCESS;
17530 }
17531
17532 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17533 {
17534         uint32_t cntr_notifies_0;
17535         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17536         ndr->depth++;
17537         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17538         ndr_print_uint32(ndr, "flags", r->flags);
17539         ndr_print_uint32(ndr, "count", r->count);
17540         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17541         ndr->depth++;
17542         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17543                 char *idx_0=NULL;
17544                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17545                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17546                         free(idx_0);
17547                 }
17548         }
17549         ndr->depth--;
17550         ndr->depth--;
17551 }
17552
17553 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17554 {
17555         if (ndr_flags & NDR_SCALARS) {
17556                 int level = ndr_push_get_switch_value(ndr, r);
17557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17558                 switch (level) {
17559                         case 0: {
17560                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17561                         break; }
17562
17563                         default:
17564                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17565                 }
17566         }
17567         if (ndr_flags & NDR_BUFFERS) {
17568                 int level = ndr_push_get_switch_value(ndr, r);
17569                 switch (level) {
17570                         case 0:
17571                                 if (r->info0) {
17572                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17573                                 }
17574                         break;
17575
17576                         default:
17577                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17578                 }
17579         }
17580         return NDR_ERR_SUCCESS;
17581 }
17582
17583 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17584 {
17585         int level;
17586         uint32_t _level;
17587         TALLOC_CTX *_mem_save_info0_0;
17588         level = ndr_pull_get_switch_value(ndr, r);
17589         if (ndr_flags & NDR_SCALARS) {
17590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17591                 if (_level != level) {
17592                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17593                 }
17594                 switch (level) {
17595                         case 0: {
17596                                 uint32_t _ptr_info0;
17597                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17598                                 if (_ptr_info0) {
17599                                         NDR_PULL_ALLOC(ndr, r->info0);
17600                                 } else {
17601                                         r->info0 = NULL;
17602                                 }
17603                         break; }
17604
17605                         default:
17606                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17607                 }
17608         }
17609         if (ndr_flags & NDR_BUFFERS) {
17610                 switch (level) {
17611                         case 0:
17612                                 if (r->info0) {
17613                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17614                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17615                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17616                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17617                                 }
17618                         break;
17619
17620                         default:
17621                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17622                 }
17623         }
17624         return NDR_ERR_SUCCESS;
17625 }
17626
17627 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17628 {
17629         int level;
17630         level = ndr_print_get_switch_value(ndr, r);
17631         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17632         switch (level) {
17633                 case 0:
17634                         ndr_print_ptr(ndr, "info0", r->info0);
17635                         ndr->depth++;
17636                         if (r->info0) {
17637                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17638                         }
17639                         ndr->depth--;
17640                 break;
17641
17642                 default:
17643                         ndr_print_bad_level(ndr, name, level);
17644         }
17645 }
17646
17647 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17648 {
17649         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17650         return NDR_ERR_SUCCESS;
17651 }
17652
17653 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17654 {
17655         uint32_t v;
17656         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17657         *r = v;
17658         return NDR_ERR_SUCCESS;
17659 }
17660
17661 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17662 {
17663         ndr_print_uint32(ndr, name, r);
17664         ndr->depth++;
17665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17668         ndr->depth--;
17669 }
17670
17671 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17672 {
17673         if (ndr_flags & NDR_SCALARS) {
17674                 NDR_CHECK(ndr_push_align(ndr, 4));
17675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17679                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17680                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17681                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17682         }
17683         if (ndr_flags & NDR_BUFFERS) {
17684                 if (r->client) {
17685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17689                 }
17690                 if (r->user) {
17691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17695                 }
17696         }
17697         return NDR_ERR_SUCCESS;
17698 }
17699
17700 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17701 {
17702         uint32_t _ptr_client;
17703         TALLOC_CTX *_mem_save_client_0;
17704         uint32_t _ptr_user;
17705         TALLOC_CTX *_mem_save_user_0;
17706         if (ndr_flags & NDR_SCALARS) {
17707                 NDR_CHECK(ndr_pull_align(ndr, 4));
17708                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17710                 if (_ptr_client) {
17711                         NDR_PULL_ALLOC(ndr, r->client);
17712                 } else {
17713                         r->client = NULL;
17714                 }
17715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17716                 if (_ptr_user) {
17717                         NDR_PULL_ALLOC(ndr, r->user);
17718                 } else {
17719                         r->user = NULL;
17720                 }
17721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17722                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17723                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17724                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17725         }
17726         if (ndr_flags & NDR_BUFFERS) {
17727                 if (r->client) {
17728                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17729                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17732                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17733                                 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));
17734                         }
17735                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17736                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17738                 }
17739                 if (r->user) {
17740                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17741                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17742                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17743                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17744                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17745                                 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));
17746                         }
17747                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17748                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17750                 }
17751         }
17752         return NDR_ERR_SUCCESS;
17753 }
17754
17755 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17756 {
17757         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17758         ndr->depth++;
17759         ndr_print_uint32(ndr, "size", r->size);
17760         ndr_print_ptr(ndr, "client", r->client);
17761         ndr->depth++;
17762         if (r->client) {
17763                 ndr_print_string(ndr, "client", r->client);
17764         }
17765         ndr->depth--;
17766         ndr_print_ptr(ndr, "user", r->user);
17767         ndr->depth++;
17768         if (r->user) {
17769                 ndr_print_string(ndr, "user", r->user);
17770         }
17771         ndr->depth--;
17772         ndr_print_uint32(ndr, "build", r->build);
17773         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17774         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17775         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17776         ndr->depth--;
17777 }
17778
17779 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17780 {
17781         if (ndr_flags & NDR_SCALARS) {
17782                 NDR_CHECK(ndr_push_align(ndr, 4));
17783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17784         }
17785         if (ndr_flags & NDR_BUFFERS) {
17786         }
17787         return NDR_ERR_SUCCESS;
17788 }
17789
17790 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17791 {
17792         if (ndr_flags & NDR_SCALARS) {
17793                 NDR_CHECK(ndr_pull_align(ndr, 4));
17794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17795         }
17796         if (ndr_flags & NDR_BUFFERS) {
17797         }
17798         return NDR_ERR_SUCCESS;
17799 }
17800
17801 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17802 {
17803         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17804         ndr->depth++;
17805         ndr_print_uint32(ndr, "not_used", r->not_used);
17806         ndr->depth--;
17807 }
17808
17809 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17810 {
17811         if (ndr_flags & NDR_SCALARS) {
17812                 NDR_CHECK(ndr_push_align(ndr, 4));
17813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17819                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17820                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17821                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17822                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17823         }
17824         if (ndr_flags & NDR_BUFFERS) {
17825                 if (r->client) {
17826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17830                 }
17831                 if (r->user) {
17832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17836                 }
17837         }
17838         return NDR_ERR_SUCCESS;
17839 }
17840
17841 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17842 {
17843         uint32_t _ptr_client;
17844         TALLOC_CTX *_mem_save_client_0;
17845         uint32_t _ptr_user;
17846         TALLOC_CTX *_mem_save_user_0;
17847         if (ndr_flags & NDR_SCALARS) {
17848                 NDR_CHECK(ndr_pull_align(ndr, 4));
17849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17853                 if (_ptr_client) {
17854                         NDR_PULL_ALLOC(ndr, r->client);
17855                 } else {
17856                         r->client = NULL;
17857                 }
17858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17859                 if (_ptr_user) {
17860                         NDR_PULL_ALLOC(ndr, r->user);
17861                 } else {
17862                         r->user = NULL;
17863                 }
17864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17865                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17866                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17867                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17868                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17869         }
17870         if (ndr_flags & NDR_BUFFERS) {
17871                 if (r->client) {
17872                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17873                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17875                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17876                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17877                                 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));
17878                         }
17879                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17880                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17882                 }
17883                 if (r->user) {
17884                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17885                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17886                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17887                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17888                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17889                                 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));
17890                         }
17891                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17892                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17893                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17894                 }
17895         }
17896         return NDR_ERR_SUCCESS;
17897 }
17898
17899 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17900 {
17901         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17902         ndr->depth++;
17903         ndr_print_uint32(ndr, "size", r->size);
17904         ndr_print_uint32(ndr, "flags", r->flags);
17905         ndr_print_uint32(ndr, "size2", r->size2);
17906         ndr_print_ptr(ndr, "client", r->client);
17907         ndr->depth++;
17908         if (r->client) {
17909                 ndr_print_string(ndr, "client", r->client);
17910         }
17911         ndr->depth--;
17912         ndr_print_ptr(ndr, "user", r->user);
17913         ndr->depth++;
17914         if (r->user) {
17915                 ndr_print_string(ndr, "user", r->user);
17916         }
17917         ndr->depth--;
17918         ndr_print_uint32(ndr, "build", r->build);
17919         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17920         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17921         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17922         ndr_print_udlong(ndr, "reserved", r->reserved);
17923         ndr->depth--;
17924 }
17925
17926 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17927 {
17928         if (ndr_flags & NDR_SCALARS) {
17929                 int level = ndr_push_get_switch_value(ndr, r);
17930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17931                 switch (level) {
17932                         case 1: {
17933                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
17934                         break; }
17935
17936                         case 2: {
17937                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
17938                         break; }
17939
17940                         case 3: {
17941                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
17942                         break; }
17943
17944                         default:
17945                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17946                 }
17947         }
17948         if (ndr_flags & NDR_BUFFERS) {
17949                 int level = ndr_push_get_switch_value(ndr, r);
17950                 switch (level) {
17951                         case 1:
17952                                 if (r->level1) {
17953                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
17954                                 }
17955                         break;
17956
17957                         case 2:
17958                                 if (r->level2) {
17959                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
17960                                 }
17961                         break;
17962
17963                         case 3:
17964                                 if (r->level3) {
17965                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
17966                                 }
17967                         break;
17968
17969                         default:
17970                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17971                 }
17972         }
17973         return NDR_ERR_SUCCESS;
17974 }
17975
17976 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
17977 {
17978         int level;
17979         uint32_t _level;
17980         TALLOC_CTX *_mem_save_level1_0;
17981         TALLOC_CTX *_mem_save_level2_0;
17982         TALLOC_CTX *_mem_save_level3_0;
17983         level = ndr_pull_get_switch_value(ndr, r);
17984         if (ndr_flags & NDR_SCALARS) {
17985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17986                 if (_level != level) {
17987                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17988                 }
17989                 switch (level) {
17990                         case 1: {
17991                                 uint32_t _ptr_level1;
17992                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
17993                                 if (_ptr_level1) {
17994                                         NDR_PULL_ALLOC(ndr, r->level1);
17995                                 } else {
17996                                         r->level1 = NULL;
17997                                 }
17998                         break; }
17999
18000                         case 2: {
18001                                 uint32_t _ptr_level2;
18002                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18003                                 if (_ptr_level2) {
18004                                         NDR_PULL_ALLOC(ndr, r->level2);
18005                                 } else {
18006                                         r->level2 = NULL;
18007                                 }
18008                         break; }
18009
18010                         case 3: {
18011                                 uint32_t _ptr_level3;
18012                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18013                                 if (_ptr_level3) {
18014                                         NDR_PULL_ALLOC(ndr, r->level3);
18015                                 } else {
18016                                         r->level3 = NULL;
18017                                 }
18018                         break; }
18019
18020                         default:
18021                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18022                 }
18023         }
18024         if (ndr_flags & NDR_BUFFERS) {
18025                 switch (level) {
18026                         case 1:
18027                                 if (r->level1) {
18028                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18029                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18030                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18031                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18032                                 }
18033                         break;
18034
18035                         case 2:
18036                                 if (r->level2) {
18037                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18038                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18039                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18040                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18041                                 }
18042                         break;
18043
18044                         case 3:
18045                                 if (r->level3) {
18046                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18047                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18048                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18049                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18050                                 }
18051                         break;
18052
18053                         default:
18054                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18055                 }
18056         }
18057         return NDR_ERR_SUCCESS;
18058 }
18059
18060 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18061 {
18062         int level;
18063         level = ndr_print_get_switch_value(ndr, r);
18064         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18065         switch (level) {
18066                 case 1:
18067                         ndr_print_ptr(ndr, "level1", r->level1);
18068                         ndr->depth++;
18069                         if (r->level1) {
18070                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18071                         }
18072                         ndr->depth--;
18073                 break;
18074
18075                 case 2:
18076                         ndr_print_ptr(ndr, "level2", r->level2);
18077                         ndr->depth++;
18078                         if (r->level2) {
18079                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18080                         }
18081                         ndr->depth--;
18082                 break;
18083
18084                 case 3:
18085                         ndr_print_ptr(ndr, "level3", r->level3);
18086                         ndr->depth++;
18087                         if (r->level3) {
18088                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18089                         }
18090                         ndr->depth--;
18091                 break;
18092
18093                 default:
18094                         ndr_print_bad_level(ndr, name, level);
18095         }
18096 }
18097
18098 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18099 {
18100         if (ndr_flags & NDR_SCALARS) {
18101                 NDR_CHECK(ndr_push_align(ndr, 4));
18102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18103                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18104                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18105         }
18106         if (ndr_flags & NDR_BUFFERS) {
18107                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18108         }
18109         return NDR_ERR_SUCCESS;
18110 }
18111
18112 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18113 {
18114         if (ndr_flags & NDR_SCALARS) {
18115                 NDR_CHECK(ndr_pull_align(ndr, 4));
18116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18117                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18118                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18119         }
18120         if (ndr_flags & NDR_BUFFERS) {
18121                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18122         }
18123         return NDR_ERR_SUCCESS;
18124 }
18125
18126 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18127 {
18128         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18129         ndr->depth++;
18130         ndr_print_uint32(ndr, "level", r->level);
18131         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18132         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18133         ndr->depth--;
18134 }
18135
18136 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18137 {
18138         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18139         return NDR_ERR_SUCCESS;
18140 }
18141
18142 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18143 {
18144         uint32_t v;
18145         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18146         *r = v;
18147         return NDR_ERR_SUCCESS;
18148 }
18149
18150 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18151 {
18152         ndr_print_uint32(ndr, name, r);
18153         ndr->depth++;
18154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18156         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18158         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18159         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18160         ndr->depth--;
18161 }
18162
18163 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18164 {
18165         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18166         return NDR_ERR_SUCCESS;
18167 }
18168
18169 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18170 {
18171         uint32_t v;
18172         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18173         *r = v;
18174         return NDR_ERR_SUCCESS;
18175 }
18176
18177 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18178 {
18179         ndr_print_uint32(ndr, name, r);
18180         ndr->depth++;
18181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18184         ndr->depth--;
18185 }
18186
18187 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18188 {
18189         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18190         return NDR_ERR_SUCCESS;
18191 }
18192
18193 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18194 {
18195         uint32_t v;
18196         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18197         *r = v;
18198         return NDR_ERR_SUCCESS;
18199 }
18200
18201 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18202 {
18203         const char *val = NULL;
18204
18205         switch (r) {
18206                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18207                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18208         }
18209         ndr_print_enum(ndr, name, "ENUM", val, r);
18210 }
18211
18212 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18213 {
18214         if (ndr_flags & NDR_SCALARS) {
18215                 NDR_CHECK(ndr_push_align(ndr, 4));
18216                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18218                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18221                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18222                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18224                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18225                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18226                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18227                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18231         }
18232         if (ndr_flags & NDR_BUFFERS) {
18233         }
18234         return NDR_ERR_SUCCESS;
18235 }
18236
18237 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18238 {
18239         if (ndr_flags & NDR_SCALARS) {
18240                 NDR_CHECK(ndr_pull_align(ndr, 4));
18241                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18243                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18246                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18247                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18249                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18250                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18251                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18252                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18256         }
18257         if (ndr_flags & NDR_BUFFERS) {
18258         }
18259         return NDR_ERR_SUCCESS;
18260 }
18261
18262 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18263 {
18264         ndr_print_struct(ndr, name, "spoolss_PortData1");
18265         ndr->depth++;
18266         ndr_print_string(ndr, "portname", r->portname);
18267         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18268         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18269         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18270         ndr_print_uint32(ndr, "reserved", r->reserved);
18271         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18272         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18273         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18274         ndr_print_string(ndr, "queue", r->queue);
18275         ndr_print_string(ndr, "ip_address", r->ip_address);
18276         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18277         ndr_print_string(ndr, "device_type", r->device_type);
18278         ndr_print_uint32(ndr, "port_number", r->port_number);
18279         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18280         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18281         ndr->depth--;
18282 }
18283
18284 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18285 {
18286         if (ndr_flags & NDR_SCALARS) {
18287                 NDR_CHECK(ndr_push_align(ndr, 4));
18288                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18290                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18293                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18294                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18296                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18297                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18302         }
18303         if (ndr_flags & NDR_BUFFERS) {
18304         }
18305         return NDR_ERR_SUCCESS;
18306 }
18307
18308 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18309 {
18310         if (ndr_flags & NDR_SCALARS) {
18311                 NDR_CHECK(ndr_pull_align(ndr, 4));
18312                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18314                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18317                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18318                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18320                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18321                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18326         }
18327         if (ndr_flags & NDR_BUFFERS) {
18328         }
18329         return NDR_ERR_SUCCESS;
18330 }
18331
18332 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18333 {
18334         ndr_print_struct(ndr, name, "spoolss_PortData2");
18335         ndr->depth++;
18336         ndr_print_string(ndr, "portname", r->portname);
18337         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18338         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18339         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18340         ndr_print_uint32(ndr, "reserved", r->reserved);
18341         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18342         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18343         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18344         ndr_print_string(ndr, "queue", r->queue);
18345         ndr_print_string(ndr, "device_type", r->device_type);
18346         ndr_print_uint32(ndr, "port_number", r->port_number);
18347         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18348         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18349         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18350         ndr->depth--;
18351 }
18352
18353 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18354 {
18355         if (ndr_flags & NDR_SCALARS) {
18356                 NDR_CHECK(ndr_push_align(ndr, 4));
18357                 {
18358                         uint32_t _flags_save_string = ndr->flags;
18359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18360                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18361                         ndr->flags = _flags_save_string;
18362                 }
18363         }
18364         if (ndr_flags & NDR_BUFFERS) {
18365         }
18366         return NDR_ERR_SUCCESS;
18367 }
18368
18369 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18370 {
18371         if (ndr_flags & NDR_SCALARS) {
18372                 NDR_CHECK(ndr_pull_align(ndr, 4));
18373                 {
18374                         uint32_t _flags_save_string = ndr->flags;
18375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18376                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18377                         ndr->flags = _flags_save_string;
18378                 }
18379         }
18380         if (ndr_flags & NDR_BUFFERS) {
18381         }
18382         return NDR_ERR_SUCCESS;
18383 }
18384
18385 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18386 {
18387         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18388         ndr->depth++;
18389         ndr_print_string(ndr, "dll_name", r->dll_name);
18390         ndr->depth--;
18391 }
18392
18393 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18394 {
18395         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18396         return NDR_ERR_SUCCESS;
18397 }
18398
18399 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18400 {
18401         uint32_t v;
18402         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18403         *r = v;
18404         return NDR_ERR_SUCCESS;
18405 }
18406
18407 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18408 {
18409         ndr_print_uint32(ndr, name, r);
18410         ndr->depth++;
18411         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18412         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18413         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18414         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18415         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18416         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18417         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18418         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18419         ndr->depth--;
18420 }
18421
18422 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18423 {
18424         if (flags & NDR_IN) {
18425                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18427                 if (r->in.server) {
18428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18432                 }
18433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18435                 if (r->in.buffer) {
18436                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18437                 }
18438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18439         }
18440         if (flags & NDR_OUT) {
18441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18442                 if (r->out.info) {
18443                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18444                 }
18445                 if (r->out.needed == NULL) {
18446                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18447                 }
18448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18449                 if (r->out.count == NULL) {
18450                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18451                 }
18452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18453                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18454         }
18455         return NDR_ERR_SUCCESS;
18456 }
18457
18458 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18459 {
18460         uint32_t _ptr_server;
18461         uint32_t _ptr_buffer;
18462         uint32_t _ptr_info;
18463         TALLOC_CTX *_mem_save_server_0;
18464         TALLOC_CTX *_mem_save_buffer_0;
18465         TALLOC_CTX *_mem_save_info_0;
18466         TALLOC_CTX *_mem_save_needed_0;
18467         TALLOC_CTX *_mem_save_count_0;
18468         if (flags & NDR_IN) {
18469                 ZERO_STRUCT(r->out);
18470
18471                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18473                 if (_ptr_server) {
18474                         NDR_PULL_ALLOC(ndr, r->in.server);
18475                 } else {
18476                         r->in.server = NULL;
18477                 }
18478                 if (r->in.server) {
18479                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18480                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18481                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18482                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18483                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18484                                 return 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));
18485                         }
18486                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18487                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18489                 }
18490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18492                 if (_ptr_buffer) {
18493                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18494                 } else {
18495                         r->in.buffer = NULL;
18496                 }
18497                 if (r->in.buffer) {
18498                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18499                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18500                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18502                 }
18503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18504                 NDR_PULL_ALLOC(ndr, r->out.needed);
18505                 ZERO_STRUCTP(r->out.needed);
18506                 NDR_PULL_ALLOC(ndr, r->out.count);
18507                 ZERO_STRUCTP(r->out.count);
18508         }
18509         if (flags & NDR_OUT) {
18510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18511                 if (_ptr_info) {
18512                         NDR_PULL_ALLOC(ndr, r->out.info);
18513                 } else {
18514                         r->out.info = NULL;
18515                 }
18516                 if (r->out.info) {
18517                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18518                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18519                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18521                 }
18522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18523                         NDR_PULL_ALLOC(ndr, r->out.needed);
18524                 }
18525                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18530                         NDR_PULL_ALLOC(ndr, r->out.count);
18531                 }
18532                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18533                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18537         }
18538         return NDR_ERR_SUCCESS;
18539 }
18540
18541 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18542 {
18543         uint32_t cntr_info_0;
18544         if (flags & NDR_IN) {
18545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18547         }
18548         if (flags & NDR_OUT) {
18549                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18550                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18551                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18552                 }
18553                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18554                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18555                 }
18556         }
18557         return NDR_ERR_SUCCESS;
18558 }
18559
18560 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18561 {
18562         uint32_t cntr_info_0;
18563         TALLOC_CTX *_mem_save_info_0;
18564         if (flags & NDR_IN) {
18565                 ZERO_STRUCT(r->out);
18566
18567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18569         }
18570         if (flags & NDR_OUT) {
18571                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18572                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18573                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18574                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18575                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18576                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18577                 }
18578                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18579                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18580                 }
18581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18582         }
18583         return NDR_ERR_SUCCESS;
18584 }
18585
18586 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18587 {
18588         uint32_t cntr_info_2;
18589         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18590         ndr->depth++;
18591         if (flags & NDR_SET_VALUES) {
18592                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18593         }
18594         if (flags & NDR_IN) {
18595                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18596                 ndr->depth++;
18597                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18598                 ndr_print_ptr(ndr, "server", r->in.server);
18599                 ndr->depth++;
18600                 if (r->in.server) {
18601                         ndr_print_string(ndr, "server", r->in.server);
18602                 }
18603                 ndr->depth--;
18604                 ndr_print_uint32(ndr, "level", r->in.level);
18605                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18606                 ndr->depth++;
18607                 if (r->in.buffer) {
18608                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18609                 }
18610                 ndr->depth--;
18611                 ndr_print_uint32(ndr, "offered", r->in.offered);
18612                 ndr->depth--;
18613         }
18614         if (flags & NDR_OUT) {
18615                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18616                 ndr->depth++;
18617                 ndr_print_ptr(ndr, "count", r->out.count);
18618                 ndr->depth++;
18619                 ndr_print_uint32(ndr, "count", *r->out.count);
18620                 ndr->depth--;
18621                 ndr_print_ptr(ndr, "info", r->out.info);
18622                 ndr->depth++;
18623                 ndr_print_ptr(ndr, "info", *r->out.info);
18624                 ndr->depth++;
18625                 if (*r->out.info) {
18626                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18627                         ndr->depth++;
18628                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18629                                 char *idx_2=NULL;
18630                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18631                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18632                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18633                                         free(idx_2);
18634                                 }
18635                         }
18636                         ndr->depth--;
18637                 }
18638                 ndr->depth--;
18639                 ndr->depth--;
18640                 ndr_print_ptr(ndr, "needed", r->out.needed);
18641                 ndr->depth++;
18642                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18643                 ndr->depth--;
18644                 ndr_print_WERROR(ndr, "result", r->out.result);
18645                 ndr->depth--;
18646         }
18647         ndr->depth--;
18648 }
18649
18650 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18651 {
18652         if (flags & NDR_IN) {
18653                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18654                 if (r->in.printername) {
18655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18659                 }
18660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18661                 if (r->in.datatype) {
18662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18665                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18666                 }
18667                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18668                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18669         }
18670         if (flags & NDR_OUT) {
18671                 if (r->out.handle == NULL) {
18672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18673                 }
18674                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18675                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18676         }
18677         return NDR_ERR_SUCCESS;
18678 }
18679
18680 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18681 {
18682         uint32_t _ptr_printername;
18683         uint32_t _ptr_datatype;
18684         TALLOC_CTX *_mem_save_printername_0;
18685         TALLOC_CTX *_mem_save_datatype_0;
18686         TALLOC_CTX *_mem_save_handle_0;
18687         if (flags & NDR_IN) {
18688                 ZERO_STRUCT(r->out);
18689
18690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18691                 if (_ptr_printername) {
18692                         NDR_PULL_ALLOC(ndr, r->in.printername);
18693                 } else {
18694                         r->in.printername = NULL;
18695                 }
18696                 if (r->in.printername) {
18697                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18698                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18699                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18700                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18701                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18702                                 return 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));
18703                         }
18704                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18705                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18707                 }
18708                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18709                 if (_ptr_datatype) {
18710                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18711                 } else {
18712                         r->in.datatype = NULL;
18713                 }
18714                 if (r->in.datatype) {
18715                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18716                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18719                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18720                                 return 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));
18721                         }
18722                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18723                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18725                 }
18726                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18727                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18728                 NDR_PULL_ALLOC(ndr, r->out.handle);
18729                 ZERO_STRUCTP(r->out.handle);
18730         }
18731         if (flags & NDR_OUT) {
18732                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18733                         NDR_PULL_ALLOC(ndr, r->out.handle);
18734                 }
18735                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18736                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18737                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18738                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18739                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18740         }
18741         return NDR_ERR_SUCCESS;
18742 }
18743
18744 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18745 {
18746         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18747         ndr->depth++;
18748         if (flags & NDR_SET_VALUES) {
18749                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18750         }
18751         if (flags & NDR_IN) {
18752                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18753                 ndr->depth++;
18754                 ndr_print_ptr(ndr, "printername", r->in.printername);
18755                 ndr->depth++;
18756                 if (r->in.printername) {
18757                         ndr_print_string(ndr, "printername", r->in.printername);
18758                 }
18759                 ndr->depth--;
18760                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18761                 ndr->depth++;
18762                 if (r->in.datatype) {
18763                         ndr_print_string(ndr, "datatype", r->in.datatype);
18764                 }
18765                 ndr->depth--;
18766                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18767                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18768                 ndr->depth--;
18769         }
18770         if (flags & NDR_OUT) {
18771                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18772                 ndr->depth++;
18773                 ndr_print_ptr(ndr, "handle", r->out.handle);
18774                 ndr->depth++;
18775                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18776                 ndr->depth--;
18777                 ndr_print_WERROR(ndr, "result", r->out.result);
18778                 ndr->depth--;
18779         }
18780         ndr->depth--;
18781 }
18782
18783 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18784 {
18785         if (flags & NDR_IN) {
18786                 if (r->in.handle == NULL) {
18787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18788                 }
18789                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18792                 if (r->in.ctr) {
18793                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18794                 }
18795                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18796         }
18797         if (flags & NDR_OUT) {
18798                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18799         }
18800         return NDR_ERR_SUCCESS;
18801 }
18802
18803 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18804 {
18805         uint32_t _ptr_ctr;
18806         TALLOC_CTX *_mem_save_handle_0;
18807         TALLOC_CTX *_mem_save_ctr_0;
18808         if (flags & NDR_IN) {
18809                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18810                         NDR_PULL_ALLOC(ndr, r->in.handle);
18811                 }
18812                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18813                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18814                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18818                 if (_ptr_ctr) {
18819                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18820                 } else {
18821                         r->in.ctr = NULL;
18822                 }
18823                 if (r->in.ctr) {
18824                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18826                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18828                 }
18829                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18830         }
18831         if (flags & NDR_OUT) {
18832                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18833         }
18834         return NDR_ERR_SUCCESS;
18835 }
18836
18837 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18838 {
18839         ndr_print_struct(ndr, name, "spoolss_SetJob");
18840         ndr->depth++;
18841         if (flags & NDR_SET_VALUES) {
18842                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18843         }
18844         if (flags & NDR_IN) {
18845                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18846                 ndr->depth++;
18847                 ndr_print_ptr(ndr, "handle", r->in.handle);
18848                 ndr->depth++;
18849                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18850                 ndr->depth--;
18851                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18852                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18853                 ndr->depth++;
18854                 if (r->in.ctr) {
18855                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18856                 }
18857                 ndr->depth--;
18858                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18859                 ndr->depth--;
18860         }
18861         if (flags & NDR_OUT) {
18862                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18863                 ndr->depth++;
18864                 ndr_print_WERROR(ndr, "result", r->out.result);
18865                 ndr->depth--;
18866         }
18867         ndr->depth--;
18868 }
18869
18870 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18871 {
18872         if (flags & NDR_IN) {
18873                 if (r->in.handle == NULL) {
18874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18875                 }
18876                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18879                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18880                 if (r->in.buffer) {
18881                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18882                 }
18883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18884         }
18885         if (flags & NDR_OUT) {
18886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18887                 if (r->out.info) {
18888                         {
18889                                 struct ndr_push *_ndr_info;
18890                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18891                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18892                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18893                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18894                         }
18895                 }
18896                 if (r->out.needed == NULL) {
18897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18898                 }
18899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18900                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18901         }
18902         return NDR_ERR_SUCCESS;
18903 }
18904
18905 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18906 {
18907         uint32_t _ptr_buffer;
18908         uint32_t _ptr_info;
18909         TALLOC_CTX *_mem_save_handle_0;
18910         TALLOC_CTX *_mem_save_buffer_0;
18911         TALLOC_CTX *_mem_save_info_0;
18912         TALLOC_CTX *_mem_save_needed_0;
18913         if (flags & NDR_IN) {
18914                 ZERO_STRUCT(r->out);
18915
18916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18917                         NDR_PULL_ALLOC(ndr, r->in.handle);
18918                 }
18919                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18920                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18921                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18926                 if (_ptr_buffer) {
18927                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18928                 } else {
18929                         r->in.buffer = NULL;
18930                 }
18931                 if (r->in.buffer) {
18932                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18933                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18934                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18936                 }
18937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18938                 NDR_PULL_ALLOC(ndr, r->out.needed);
18939                 ZERO_STRUCTP(r->out.needed);
18940         }
18941         if (flags & NDR_OUT) {
18942                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18943                 if (_ptr_info) {
18944                         NDR_PULL_ALLOC(ndr, r->out.info);
18945                 } else {
18946                         r->out.info = NULL;
18947                 }
18948                 if (r->out.info) {
18949                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18950                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18951                         {
18952                                 struct ndr_pull *_ndr_info;
18953                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18954                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18955                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18956                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18957                         }
18958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18959                 }
18960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18961                         NDR_PULL_ALLOC(ndr, r->out.needed);
18962                 }
18963                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18964                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18968         }
18969         return NDR_ERR_SUCCESS;
18970 }
18971
18972 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
18973 {
18974         ndr_print_struct(ndr, name, "spoolss_GetJob");
18975         ndr->depth++;
18976         if (flags & NDR_SET_VALUES) {
18977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18978         }
18979         if (flags & NDR_IN) {
18980                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
18981                 ndr->depth++;
18982                 ndr_print_ptr(ndr, "handle", r->in.handle);
18983                 ndr->depth++;
18984                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18985                 ndr->depth--;
18986                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18987                 ndr_print_uint32(ndr, "level", r->in.level);
18988                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18989                 ndr->depth++;
18990                 if (r->in.buffer) {
18991                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18992                 }
18993                 ndr->depth--;
18994                 ndr_print_uint32(ndr, "offered", r->in.offered);
18995                 ndr->depth--;
18996         }
18997         if (flags & NDR_OUT) {
18998                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
18999                 ndr->depth++;
19000                 ndr_print_ptr(ndr, "info", r->out.info);
19001                 ndr->depth++;
19002                 if (r->out.info) {
19003                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19004                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19005                 }
19006                 ndr->depth--;
19007                 ndr_print_ptr(ndr, "needed", r->out.needed);
19008                 ndr->depth++;
19009                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19010                 ndr->depth--;
19011                 ndr_print_WERROR(ndr, "result", r->out.result);
19012                 ndr->depth--;
19013         }
19014         ndr->depth--;
19015 }
19016
19017 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19018 {
19019         if (flags & NDR_IN) {
19020                 if (r->in.handle == NULL) {
19021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19022                 }
19023                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19028                 if (r->in.buffer) {
19029                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19030                 }
19031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19032         }
19033         if (flags & NDR_OUT) {
19034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19035                 if (r->out.info) {
19036                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19037                 }
19038                 if (r->out.needed == NULL) {
19039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19040                 }
19041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19042                 if (r->out.count == NULL) {
19043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19044                 }
19045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19047         }
19048         return NDR_ERR_SUCCESS;
19049 }
19050
19051 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19052 {
19053         uint32_t _ptr_buffer;
19054         uint32_t _ptr_info;
19055         TALLOC_CTX *_mem_save_handle_0;
19056         TALLOC_CTX *_mem_save_buffer_0;
19057         TALLOC_CTX *_mem_save_info_0;
19058         TALLOC_CTX *_mem_save_needed_0;
19059         TALLOC_CTX *_mem_save_count_0;
19060         if (flags & NDR_IN) {
19061                 ZERO_STRUCT(r->out);
19062
19063                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19064                         NDR_PULL_ALLOC(ndr, r->in.handle);
19065                 }
19066                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19067                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19068                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19074                 if (_ptr_buffer) {
19075                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19076                 } else {
19077                         r->in.buffer = NULL;
19078                 }
19079                 if (r->in.buffer) {
19080                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19082                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19084                 }
19085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19086                 NDR_PULL_ALLOC(ndr, r->out.needed);
19087                 ZERO_STRUCTP(r->out.needed);
19088                 NDR_PULL_ALLOC(ndr, r->out.count);
19089                 ZERO_STRUCTP(r->out.count);
19090         }
19091         if (flags & NDR_OUT) {
19092                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19093                 if (_ptr_info) {
19094                         NDR_PULL_ALLOC(ndr, r->out.info);
19095                 } else {
19096                         r->out.info = NULL;
19097                 }
19098                 if (r->out.info) {
19099                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19100                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19101                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19103                 }
19104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19105                         NDR_PULL_ALLOC(ndr, r->out.needed);
19106                 }
19107                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19108                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19111                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19112                         NDR_PULL_ALLOC(ndr, r->out.count);
19113                 }
19114                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19115                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19118                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19119         }
19120         return NDR_ERR_SUCCESS;
19121 }
19122
19123 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19124 {
19125         uint32_t cntr_info_0;
19126         if (flags & NDR_IN) {
19127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19129         }
19130         if (flags & NDR_OUT) {
19131                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19132                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19133                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19134                 }
19135                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19136                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19137                 }
19138         }
19139         return NDR_ERR_SUCCESS;
19140 }
19141
19142 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19143 {
19144         uint32_t cntr_info_0;
19145         TALLOC_CTX *_mem_save_info_0;
19146         if (flags & NDR_IN) {
19147                 ZERO_STRUCT(r->out);
19148
19149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19151         }
19152         if (flags & NDR_OUT) {
19153                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19154                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19155                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19156                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19157                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19158                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19159                 }
19160                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19161                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19162                 }
19163                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19164         }
19165         return NDR_ERR_SUCCESS;
19166 }
19167
19168 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19169 {
19170         uint32_t cntr_info_2;
19171         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19172         ndr->depth++;
19173         if (flags & NDR_SET_VALUES) {
19174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19175         }
19176         if (flags & NDR_IN) {
19177                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19178                 ndr->depth++;
19179                 ndr_print_ptr(ndr, "handle", r->in.handle);
19180                 ndr->depth++;
19181                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19182                 ndr->depth--;
19183                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19184                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19185                 ndr_print_uint32(ndr, "level", r->in.level);
19186                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19187                 ndr->depth++;
19188                 if (r->in.buffer) {
19189                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19190                 }
19191                 ndr->depth--;
19192                 ndr_print_uint32(ndr, "offered", r->in.offered);
19193                 ndr->depth--;
19194         }
19195         if (flags & NDR_OUT) {
19196                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19197                 ndr->depth++;
19198                 ndr_print_ptr(ndr, "count", r->out.count);
19199                 ndr->depth++;
19200                 ndr_print_uint32(ndr, "count", *r->out.count);
19201                 ndr->depth--;
19202                 ndr_print_ptr(ndr, "info", r->out.info);
19203                 ndr->depth++;
19204                 ndr_print_ptr(ndr, "info", *r->out.info);
19205                 ndr->depth++;
19206                 if (*r->out.info) {
19207                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19208                         ndr->depth++;
19209                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19210                                 char *idx_2=NULL;
19211                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19212                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19213                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19214                                         free(idx_2);
19215                                 }
19216                         }
19217                         ndr->depth--;
19218                 }
19219                 ndr->depth--;
19220                 ndr->depth--;
19221                 ndr_print_ptr(ndr, "needed", r->out.needed);
19222                 ndr->depth++;
19223                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19224                 ndr->depth--;
19225                 ndr_print_WERROR(ndr, "result", r->out.result);
19226                 ndr->depth--;
19227         }
19228         ndr->depth--;
19229 }
19230
19231 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19232 {
19233         if (flags & NDR_IN) {
19234         }
19235         if (flags & NDR_OUT) {
19236                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19237         }
19238         return NDR_ERR_SUCCESS;
19239 }
19240
19241 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19242 {
19243         if (flags & NDR_IN) {
19244         }
19245         if (flags & NDR_OUT) {
19246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19247         }
19248         return NDR_ERR_SUCCESS;
19249 }
19250
19251 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19252 {
19253         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19254         ndr->depth++;
19255         if (flags & NDR_SET_VALUES) {
19256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19257         }
19258         if (flags & NDR_IN) {
19259                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19260                 ndr->depth++;
19261                 ndr->depth--;
19262         }
19263         if (flags & NDR_OUT) {
19264                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19265                 ndr->depth++;
19266                 ndr_print_WERROR(ndr, "result", r->out.result);
19267                 ndr->depth--;
19268         }
19269         ndr->depth--;
19270 }
19271
19272 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19273 {
19274         if (flags & NDR_IN) {
19275                 if (r->in.handle == NULL) {
19276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19277                 }
19278                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19279         }
19280         if (flags & NDR_OUT) {
19281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19282         }
19283         return NDR_ERR_SUCCESS;
19284 }
19285
19286 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19287 {
19288         TALLOC_CTX *_mem_save_handle_0;
19289         if (flags & NDR_IN) {
19290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19291                         NDR_PULL_ALLOC(ndr, r->in.handle);
19292                 }
19293                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19294                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19295                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19297         }
19298         if (flags & NDR_OUT) {
19299                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19300         }
19301         return NDR_ERR_SUCCESS;
19302 }
19303
19304 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19305 {
19306         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19307         ndr->depth++;
19308         if (flags & NDR_SET_VALUES) {
19309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19310         }
19311         if (flags & NDR_IN) {
19312                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19313                 ndr->depth++;
19314                 ndr_print_ptr(ndr, "handle", r->in.handle);
19315                 ndr->depth++;
19316                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19317                 ndr->depth--;
19318                 ndr->depth--;
19319         }
19320         if (flags & NDR_OUT) {
19321                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19322                 ndr->depth++;
19323                 ndr_print_WERROR(ndr, "result", r->out.result);
19324                 ndr->depth--;
19325         }
19326         ndr->depth--;
19327 }
19328
19329 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19330 {
19331         if (flags & NDR_IN) {
19332                 if (r->in.handle == NULL) {
19333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19334                 }
19335                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19336                 if (r->in.info_ctr == NULL) {
19337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19338                 }
19339                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19340                 if (r->in.devmode_ctr == NULL) {
19341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19342                 }
19343                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19344                 if (r->in.secdesc_ctr == NULL) {
19345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19346                 }
19347                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19348                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19349         }
19350         if (flags & NDR_OUT) {
19351                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19352         }
19353         return NDR_ERR_SUCCESS;
19354 }
19355
19356 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19357 {
19358         TALLOC_CTX *_mem_save_handle_0;
19359         TALLOC_CTX *_mem_save_info_ctr_0;
19360         TALLOC_CTX *_mem_save_devmode_ctr_0;
19361         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19362         if (flags & NDR_IN) {
19363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19364                         NDR_PULL_ALLOC(ndr, r->in.handle);
19365                 }
19366                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19371                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19372                 }
19373                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19374                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19375                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19377                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19378                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19379                 }
19380                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19381                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19382                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19383                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19385                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19386                 }
19387                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19388                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19389                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19391                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19392         }
19393         if (flags & NDR_OUT) {
19394                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19395         }
19396         return NDR_ERR_SUCCESS;
19397 }
19398
19399 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19400 {
19401         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19402         ndr->depth++;
19403         if (flags & NDR_SET_VALUES) {
19404                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19405         }
19406         if (flags & NDR_IN) {
19407                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19408                 ndr->depth++;
19409                 ndr_print_ptr(ndr, "handle", r->in.handle);
19410                 ndr->depth++;
19411                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19412                 ndr->depth--;
19413                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19414                 ndr->depth++;
19415                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19416                 ndr->depth--;
19417                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19418                 ndr->depth++;
19419                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19420                 ndr->depth--;
19421                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19422                 ndr->depth++;
19423                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19424                 ndr->depth--;
19425                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19426                 ndr->depth--;
19427         }
19428         if (flags & NDR_OUT) {
19429                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19430                 ndr->depth++;
19431                 ndr_print_WERROR(ndr, "result", r->out.result);
19432                 ndr->depth--;
19433         }
19434         ndr->depth--;
19435 }
19436
19437 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19438 {
19439         if (flags & NDR_IN) {
19440                 if (r->in.handle == NULL) {
19441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19442                 }
19443                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19446                 if (r->in.buffer) {
19447                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19448                 }
19449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19450         }
19451         if (flags & NDR_OUT) {
19452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19453                 if (r->out.info) {
19454                         {
19455                                 struct ndr_push *_ndr_info;
19456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19457                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19458                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19459                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19460                         }
19461                 }
19462                 if (r->out.needed == NULL) {
19463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19464                 }
19465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19467         }
19468         return NDR_ERR_SUCCESS;
19469 }
19470
19471 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19472 {
19473         uint32_t _ptr_buffer;
19474         uint32_t _ptr_info;
19475         TALLOC_CTX *_mem_save_handle_0;
19476         TALLOC_CTX *_mem_save_buffer_0;
19477         TALLOC_CTX *_mem_save_info_0;
19478         TALLOC_CTX *_mem_save_needed_0;
19479         if (flags & NDR_IN) {
19480                 ZERO_STRUCT(r->out);
19481
19482                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19483                         NDR_PULL_ALLOC(ndr, r->in.handle);
19484                 }
19485                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19486                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19487                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19488                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19491                 if (_ptr_buffer) {
19492                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19493                 } else {
19494                         r->in.buffer = NULL;
19495                 }
19496                 if (r->in.buffer) {
19497                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19498                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19499                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19501                 }
19502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19503                 NDR_PULL_ALLOC(ndr, r->out.needed);
19504                 ZERO_STRUCTP(r->out.needed);
19505         }
19506         if (flags & NDR_OUT) {
19507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19508                 if (_ptr_info) {
19509                         NDR_PULL_ALLOC(ndr, r->out.info);
19510                 } else {
19511                         r->out.info = NULL;
19512                 }
19513                 if (r->out.info) {
19514                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19515                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19516                         {
19517                                 struct ndr_pull *_ndr_info;
19518                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19519                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19520                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19521                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19522                         }
19523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19524                 }
19525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19526                         NDR_PULL_ALLOC(ndr, r->out.needed);
19527                 }
19528                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19529                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19531                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19532                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19533         }
19534         return NDR_ERR_SUCCESS;
19535 }
19536
19537 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19538 {
19539         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19540         ndr->depth++;
19541         if (flags & NDR_SET_VALUES) {
19542                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19543         }
19544         if (flags & NDR_IN) {
19545                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19546                 ndr->depth++;
19547                 ndr_print_ptr(ndr, "handle", r->in.handle);
19548                 ndr->depth++;
19549                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19550                 ndr->depth--;
19551                 ndr_print_uint32(ndr, "level", r->in.level);
19552                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19553                 ndr->depth++;
19554                 if (r->in.buffer) {
19555                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19556                 }
19557                 ndr->depth--;
19558                 ndr_print_uint32(ndr, "offered", r->in.offered);
19559                 ndr->depth--;
19560         }
19561         if (flags & NDR_OUT) {
19562                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19563                 ndr->depth++;
19564                 ndr_print_ptr(ndr, "info", r->out.info);
19565                 ndr->depth++;
19566                 if (r->out.info) {
19567                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19568                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19569                 }
19570                 ndr->depth--;
19571                 ndr_print_ptr(ndr, "needed", r->out.needed);
19572                 ndr->depth++;
19573                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19574                 ndr->depth--;
19575                 ndr_print_WERROR(ndr, "result", r->out.result);
19576                 ndr->depth--;
19577         }
19578         ndr->depth--;
19579 }
19580
19581 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19582 {
19583         if (flags & NDR_IN) {
19584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19585                 if (r->in.servername) {
19586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19587                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19589                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19590                 }
19591                 if (r->in.info_ctr == NULL) {
19592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19593                 }
19594                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19595         }
19596         if (flags & NDR_OUT) {
19597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19598         }
19599         return NDR_ERR_SUCCESS;
19600 }
19601
19602 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19603 {
19604         uint32_t _ptr_servername;
19605         TALLOC_CTX *_mem_save_servername_0;
19606         TALLOC_CTX *_mem_save_info_ctr_0;
19607         if (flags & NDR_IN) {
19608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19609                 if (_ptr_servername) {
19610                         NDR_PULL_ALLOC(ndr, r->in.servername);
19611                 } else {
19612                         r->in.servername = NULL;
19613                 }
19614                 if (r->in.servername) {
19615                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19616                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19617                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19618                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19619                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19620                                 return 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));
19621                         }
19622                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19623                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19625                 }
19626                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19627                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19628                 }
19629                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19630                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19631                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19632                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19633         }
19634         if (flags & NDR_OUT) {
19635                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19636         }
19637         return NDR_ERR_SUCCESS;
19638 }
19639
19640 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19641 {
19642         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19643         ndr->depth++;
19644         if (flags & NDR_SET_VALUES) {
19645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19646         }
19647         if (flags & NDR_IN) {
19648                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19649                 ndr->depth++;
19650                 ndr_print_ptr(ndr, "servername", r->in.servername);
19651                 ndr->depth++;
19652                 if (r->in.servername) {
19653                         ndr_print_string(ndr, "servername", r->in.servername);
19654                 }
19655                 ndr->depth--;
19656                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19657                 ndr->depth++;
19658                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19659                 ndr->depth--;
19660                 ndr->depth--;
19661         }
19662         if (flags & NDR_OUT) {
19663                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19664                 ndr->depth++;
19665                 ndr_print_WERROR(ndr, "result", r->out.result);
19666                 ndr->depth--;
19667         }
19668         ndr->depth--;
19669 }
19670
19671 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19672 {
19673         if (flags & NDR_IN) {
19674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19675                 if (r->in.server) {
19676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19678                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19679                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19680                 }
19681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19682                 if (r->in.environment) {
19683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19686                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19687                 }
19688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19690                 if (r->in.buffer) {
19691                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19692                 }
19693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19694         }
19695         if (flags & NDR_OUT) {
19696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19697                 if (r->out.info) {
19698                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19699                 }
19700                 if (r->out.needed == NULL) {
19701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19702                 }
19703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19704                 if (r->out.count == NULL) {
19705                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19706                 }
19707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19709         }
19710         return NDR_ERR_SUCCESS;
19711 }
19712
19713 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19714 {
19715         uint32_t _ptr_server;
19716         uint32_t _ptr_environment;
19717         uint32_t _ptr_buffer;
19718         uint32_t _ptr_info;
19719         TALLOC_CTX *_mem_save_server_0;
19720         TALLOC_CTX *_mem_save_environment_0;
19721         TALLOC_CTX *_mem_save_buffer_0;
19722         TALLOC_CTX *_mem_save_info_0;
19723         TALLOC_CTX *_mem_save_needed_0;
19724         TALLOC_CTX *_mem_save_count_0;
19725         if (flags & NDR_IN) {
19726                 ZERO_STRUCT(r->out);
19727
19728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19729                 if (_ptr_server) {
19730                         NDR_PULL_ALLOC(ndr, r->in.server);
19731                 } else {
19732                         r->in.server = NULL;
19733                 }
19734                 if (r->in.server) {
19735                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19736                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19739                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19740                                 return 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));
19741                         }
19742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19745                 }
19746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19747                 if (_ptr_environment) {
19748                         NDR_PULL_ALLOC(ndr, r->in.environment);
19749                 } else {
19750                         r->in.environment = NULL;
19751                 }
19752                 if (r->in.environment) {
19753                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19757                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19758                                 return 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));
19759                         }
19760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19763                 }
19764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19766                 if (_ptr_buffer) {
19767                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19768                 } else {
19769                         r->in.buffer = NULL;
19770                 }
19771                 if (r->in.buffer) {
19772                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19774                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19776                 }
19777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19778                 NDR_PULL_ALLOC(ndr, r->out.needed);
19779                 ZERO_STRUCTP(r->out.needed);
19780                 NDR_PULL_ALLOC(ndr, r->out.count);
19781                 ZERO_STRUCTP(r->out.count);
19782         }
19783         if (flags & NDR_OUT) {
19784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19785                 if (_ptr_info) {
19786                         NDR_PULL_ALLOC(ndr, r->out.info);
19787                 } else {
19788                         r->out.info = NULL;
19789                 }
19790                 if (r->out.info) {
19791                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19792                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19793                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19795                 }
19796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19797                         NDR_PULL_ALLOC(ndr, r->out.needed);
19798                 }
19799                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19800                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19804                         NDR_PULL_ALLOC(ndr, r->out.count);
19805                 }
19806                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19811         }
19812         return NDR_ERR_SUCCESS;
19813 }
19814
19815 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19816 {
19817         uint32_t cntr_info_0;
19818         if (flags & NDR_IN) {
19819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19821         }
19822         if (flags & NDR_OUT) {
19823                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19824                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19825                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19826                 }
19827                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19828                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19829                 }
19830         }
19831         return NDR_ERR_SUCCESS;
19832 }
19833
19834 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19835 {
19836         uint32_t cntr_info_0;
19837         TALLOC_CTX *_mem_save_info_0;
19838         if (flags & NDR_IN) {
19839                 ZERO_STRUCT(r->out);
19840
19841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19843         }
19844         if (flags & NDR_OUT) {
19845                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19846                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19848                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19849                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19850                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19851                 }
19852                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19853                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19854                 }
19855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19856         }
19857         return NDR_ERR_SUCCESS;
19858 }
19859
19860 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19861 {
19862         uint32_t cntr_info_2;
19863         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19864         ndr->depth++;
19865         if (flags & NDR_SET_VALUES) {
19866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19867         }
19868         if (flags & NDR_IN) {
19869                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19870                 ndr->depth++;
19871                 ndr_print_ptr(ndr, "server", r->in.server);
19872                 ndr->depth++;
19873                 if (r->in.server) {
19874                         ndr_print_string(ndr, "server", r->in.server);
19875                 }
19876                 ndr->depth--;
19877                 ndr_print_ptr(ndr, "environment", r->in.environment);
19878                 ndr->depth++;
19879                 if (r->in.environment) {
19880                         ndr_print_string(ndr, "environment", r->in.environment);
19881                 }
19882                 ndr->depth--;
19883                 ndr_print_uint32(ndr, "level", r->in.level);
19884                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19885                 ndr->depth++;
19886                 if (r->in.buffer) {
19887                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19888                 }
19889                 ndr->depth--;
19890                 ndr_print_uint32(ndr, "offered", r->in.offered);
19891                 ndr->depth--;
19892         }
19893         if (flags & NDR_OUT) {
19894                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19895                 ndr->depth++;
19896                 ndr_print_ptr(ndr, "count", r->out.count);
19897                 ndr->depth++;
19898                 ndr_print_uint32(ndr, "count", *r->out.count);
19899                 ndr->depth--;
19900                 ndr_print_ptr(ndr, "info", r->out.info);
19901                 ndr->depth++;
19902                 ndr_print_ptr(ndr, "info", *r->out.info);
19903                 ndr->depth++;
19904                 if (*r->out.info) {
19905                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19906                         ndr->depth++;
19907                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19908                                 char *idx_2=NULL;
19909                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19910                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19911                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19912                                         free(idx_2);
19913                                 }
19914                         }
19915                         ndr->depth--;
19916                 }
19917                 ndr->depth--;
19918                 ndr->depth--;
19919                 ndr_print_ptr(ndr, "needed", r->out.needed);
19920                 ndr->depth++;
19921                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19922                 ndr->depth--;
19923                 ndr_print_WERROR(ndr, "result", r->out.result);
19924                 ndr->depth--;
19925         }
19926         ndr->depth--;
19927 }
19928
19929 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
19930 {
19931         if (flags & NDR_IN) {
19932         }
19933         if (flags & NDR_OUT) {
19934                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19935         }
19936         return NDR_ERR_SUCCESS;
19937 }
19938
19939 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
19940 {
19941         if (flags & NDR_IN) {
19942         }
19943         if (flags & NDR_OUT) {
19944                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19945         }
19946         return NDR_ERR_SUCCESS;
19947 }
19948
19949 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
19950 {
19951         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
19952         ndr->depth++;
19953         if (flags & NDR_SET_VALUES) {
19954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19955         }
19956         if (flags & NDR_IN) {
19957                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
19958                 ndr->depth++;
19959                 ndr->depth--;
19960         }
19961         if (flags & NDR_OUT) {
19962                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
19963                 ndr->depth++;
19964                 ndr_print_WERROR(ndr, "result", r->out.result);
19965                 ndr->depth--;
19966         }
19967         ndr->depth--;
19968 }
19969
19970 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
19971 {
19972         if (flags & NDR_IN) {
19973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19974                 if (r->in.server) {
19975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19979                 }
19980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19981                 if (r->in.environment) {
19982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19985                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19986                 }
19987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19989                 if (r->in.buffer) {
19990                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19991                 }
19992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19993         }
19994         if (flags & NDR_OUT) {
19995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19996                 if (r->out.info) {
19997                         {
19998                                 struct ndr_push *_ndr_info;
19999                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20000                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20001                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20002                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20003                         }
20004                 }
20005                 if (r->out.needed == NULL) {
20006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20007                 }
20008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20010         }
20011         return NDR_ERR_SUCCESS;
20012 }
20013
20014 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20015 {
20016         uint32_t _ptr_server;
20017         uint32_t _ptr_environment;
20018         uint32_t _ptr_buffer;
20019         uint32_t _ptr_info;
20020         TALLOC_CTX *_mem_save_server_0;
20021         TALLOC_CTX *_mem_save_environment_0;
20022         TALLOC_CTX *_mem_save_buffer_0;
20023         TALLOC_CTX *_mem_save_info_0;
20024         TALLOC_CTX *_mem_save_needed_0;
20025         if (flags & NDR_IN) {
20026                 ZERO_STRUCT(r->out);
20027
20028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20029                 if (_ptr_server) {
20030                         NDR_PULL_ALLOC(ndr, r->in.server);
20031                 } else {
20032                         r->in.server = NULL;
20033                 }
20034                 if (r->in.server) {
20035                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20036                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20039                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20040                                 return 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));
20041                         }
20042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20045                 }
20046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20047                 if (_ptr_environment) {
20048                         NDR_PULL_ALLOC(ndr, r->in.environment);
20049                 } else {
20050                         r->in.environment = NULL;
20051                 }
20052                 if (r->in.environment) {
20053                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20054                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20057                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20058                                 return 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));
20059                         }
20060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20063                 }
20064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20066                 if (_ptr_buffer) {
20067                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20068                 } else {
20069                         r->in.buffer = NULL;
20070                 }
20071                 if (r->in.buffer) {
20072                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20074                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20076                 }
20077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20078                 NDR_PULL_ALLOC(ndr, r->out.needed);
20079                 ZERO_STRUCTP(r->out.needed);
20080         }
20081         if (flags & NDR_OUT) {
20082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20083                 if (_ptr_info) {
20084                         NDR_PULL_ALLOC(ndr, r->out.info);
20085                 } else {
20086                         r->out.info = NULL;
20087                 }
20088                 if (r->out.info) {
20089                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20090                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20091                         {
20092                                 struct ndr_pull *_ndr_info;
20093                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20094                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20095                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20096                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20097                         }
20098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20099                 }
20100                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20101                         NDR_PULL_ALLOC(ndr, r->out.needed);
20102                 }
20103                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20104                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20106                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20108         }
20109         return NDR_ERR_SUCCESS;
20110 }
20111
20112 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20113 {
20114         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20115         ndr->depth++;
20116         if (flags & NDR_SET_VALUES) {
20117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20118         }
20119         if (flags & NDR_IN) {
20120                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20121                 ndr->depth++;
20122                 ndr_print_ptr(ndr, "server", r->in.server);
20123                 ndr->depth++;
20124                 if (r->in.server) {
20125                         ndr_print_string(ndr, "server", r->in.server);
20126                 }
20127                 ndr->depth--;
20128                 ndr_print_ptr(ndr, "environment", r->in.environment);
20129                 ndr->depth++;
20130                 if (r->in.environment) {
20131                         ndr_print_string(ndr, "environment", r->in.environment);
20132                 }
20133                 ndr->depth--;
20134                 ndr_print_uint32(ndr, "level", r->in.level);
20135                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20136                 ndr->depth++;
20137                 if (r->in.buffer) {
20138                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20139                 }
20140                 ndr->depth--;
20141                 ndr_print_uint32(ndr, "offered", r->in.offered);
20142                 ndr->depth--;
20143         }
20144         if (flags & NDR_OUT) {
20145                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20146                 ndr->depth++;
20147                 ndr_print_ptr(ndr, "info", r->out.info);
20148                 ndr->depth++;
20149                 if (r->out.info) {
20150                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20151                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20152                 }
20153                 ndr->depth--;
20154                 ndr_print_ptr(ndr, "needed", r->out.needed);
20155                 ndr->depth++;
20156                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20157                 ndr->depth--;
20158                 ndr_print_WERROR(ndr, "result", r->out.result);
20159                 ndr->depth--;
20160         }
20161         ndr->depth--;
20162 }
20163
20164 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20165 {
20166         if (flags & NDR_IN) {
20167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20168                 if (r->in.server) {
20169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20170                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20173                 }
20174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20177                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20181                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20182         }
20183         if (flags & NDR_OUT) {
20184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20185         }
20186         return NDR_ERR_SUCCESS;
20187 }
20188
20189 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20190 {
20191         uint32_t _ptr_server;
20192         TALLOC_CTX *_mem_save_server_0;
20193         if (flags & NDR_IN) {
20194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20195                 if (_ptr_server) {
20196                         NDR_PULL_ALLOC(ndr, r->in.server);
20197                 } else {
20198                         r->in.server = NULL;
20199                 }
20200                 if (r->in.server) {
20201                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20203                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20204                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20205                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20206                                 return 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));
20207                         }
20208                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20209                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20211                 }
20212                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20213                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20214                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20215                         return 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));
20216                 }
20217                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20218                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20219                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20220                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20221                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20222                         return 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));
20223                 }
20224                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20225                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20226         }
20227         if (flags & NDR_OUT) {
20228                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20229         }
20230         return NDR_ERR_SUCCESS;
20231 }
20232
20233 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20234 {
20235         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20236         ndr->depth++;
20237         if (flags & NDR_SET_VALUES) {
20238                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20239         }
20240         if (flags & NDR_IN) {
20241                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20242                 ndr->depth++;
20243                 ndr_print_ptr(ndr, "server", r->in.server);
20244                 ndr->depth++;
20245                 if (r->in.server) {
20246                         ndr_print_string(ndr, "server", r->in.server);
20247                 }
20248                 ndr->depth--;
20249                 ndr_print_string(ndr, "architecture", r->in.architecture);
20250                 ndr_print_string(ndr, "driver", r->in.driver);
20251                 ndr->depth--;
20252         }
20253         if (flags & NDR_OUT) {
20254                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20255                 ndr->depth++;
20256                 ndr_print_WERROR(ndr, "result", r->out.result);
20257                 ndr->depth--;
20258         }
20259         ndr->depth--;
20260 }
20261
20262 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20263 {
20264         if (flags & NDR_IN) {
20265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20266                 if (r->in.server) {
20267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20270                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20271                 }
20272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20275                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20279                 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));
20280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20283                 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));
20284         }
20285         if (flags & NDR_OUT) {
20286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20287         }
20288         return NDR_ERR_SUCCESS;
20289 }
20290
20291 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20292 {
20293         uint32_t _ptr_server;
20294         TALLOC_CTX *_mem_save_server_0;
20295         if (flags & NDR_IN) {
20296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20297                 if (_ptr_server) {
20298                         NDR_PULL_ALLOC(ndr, r->in.server);
20299                 } else {
20300                         r->in.server = NULL;
20301                 }
20302                 if (r->in.server) {
20303                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20304                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20307                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20308                                 return 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));
20309                         }
20310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20313                 }
20314                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20315                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20316                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20317                         return 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));
20318                 }
20319                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20320                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20321                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20322                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20323                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20324                         return 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));
20325                 }
20326                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20327                 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));
20328                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20329                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20330                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20331                         return 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));
20332                 }
20333                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20334                 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));
20335         }
20336         if (flags & NDR_OUT) {
20337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20338         }
20339         return NDR_ERR_SUCCESS;
20340 }
20341
20342 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20343 {
20344         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20345         ndr->depth++;
20346         if (flags & NDR_SET_VALUES) {
20347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20348         }
20349         if (flags & NDR_IN) {
20350                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20351                 ndr->depth++;
20352                 ndr_print_ptr(ndr, "server", r->in.server);
20353                 ndr->depth++;
20354                 if (r->in.server) {
20355                         ndr_print_string(ndr, "server", r->in.server);
20356                 }
20357                 ndr->depth--;
20358                 ndr_print_string(ndr, "architecture", r->in.architecture);
20359                 ndr_print_string(ndr, "path_name", r->in.path_name);
20360                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20361                 ndr->depth--;
20362         }
20363         if (flags & NDR_OUT) {
20364                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20365                 ndr->depth++;
20366                 ndr_print_WERROR(ndr, "result", r->out.result);
20367                 ndr->depth--;
20368         }
20369         ndr->depth--;
20370 }
20371
20372 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20373 {
20374         if (flags & NDR_IN) {
20375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20376                 if (r->in.servername) {
20377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20381                 }
20382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20383                 if (r->in.environment) {
20384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20387                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20388                 }
20389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20391                 if (r->in.buffer) {
20392                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20393                 }
20394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20395         }
20396         if (flags & NDR_OUT) {
20397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20398                 if (r->out.info) {
20399                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20400                 }
20401                 if (r->out.needed == NULL) {
20402                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20403                 }
20404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20405                 if (r->out.count == NULL) {
20406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20407                 }
20408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20410         }
20411         return NDR_ERR_SUCCESS;
20412 }
20413
20414 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20415 {
20416         uint32_t _ptr_servername;
20417         uint32_t _ptr_environment;
20418         uint32_t _ptr_buffer;
20419         uint32_t _ptr_info;
20420         TALLOC_CTX *_mem_save_servername_0;
20421         TALLOC_CTX *_mem_save_environment_0;
20422         TALLOC_CTX *_mem_save_buffer_0;
20423         TALLOC_CTX *_mem_save_info_0;
20424         TALLOC_CTX *_mem_save_needed_0;
20425         TALLOC_CTX *_mem_save_count_0;
20426         if (flags & NDR_IN) {
20427                 ZERO_STRUCT(r->out);
20428
20429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20430                 if (_ptr_servername) {
20431                         NDR_PULL_ALLOC(ndr, r->in.servername);
20432                 } else {
20433                         r->in.servername = NULL;
20434                 }
20435                 if (r->in.servername) {
20436                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20437                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20440                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20441                                 return 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));
20442                         }
20443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20446                 }
20447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20448                 if (_ptr_environment) {
20449                         NDR_PULL_ALLOC(ndr, r->in.environment);
20450                 } else {
20451                         r->in.environment = NULL;
20452                 }
20453                 if (r->in.environment) {
20454                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20455                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20456                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20457                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20458                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20459                                 return 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));
20460                         }
20461                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20462                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20464                 }
20465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20467                 if (_ptr_buffer) {
20468                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20469                 } else {
20470                         r->in.buffer = NULL;
20471                 }
20472                 if (r->in.buffer) {
20473                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20474                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20475                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20477                 }
20478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20479                 NDR_PULL_ALLOC(ndr, r->out.needed);
20480                 ZERO_STRUCTP(r->out.needed);
20481                 NDR_PULL_ALLOC(ndr, r->out.count);
20482                 ZERO_STRUCTP(r->out.count);
20483         }
20484         if (flags & NDR_OUT) {
20485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20486                 if (_ptr_info) {
20487                         NDR_PULL_ALLOC(ndr, r->out.info);
20488                 } else {
20489                         r->out.info = NULL;
20490                 }
20491                 if (r->out.info) {
20492                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20493                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20494                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20496                 }
20497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20498                         NDR_PULL_ALLOC(ndr, r->out.needed);
20499                 }
20500                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20501                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20504                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20505                         NDR_PULL_ALLOC(ndr, r->out.count);
20506                 }
20507                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20508                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20511                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20512         }
20513         return NDR_ERR_SUCCESS;
20514 }
20515
20516 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20517 {
20518         uint32_t cntr_info_0;
20519         if (flags & NDR_IN) {
20520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20522         }
20523         if (flags & NDR_OUT) {
20524                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20525                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20526                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20527                 }
20528                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20529                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20530                 }
20531         }
20532         return NDR_ERR_SUCCESS;
20533 }
20534
20535 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20536 {
20537         uint32_t cntr_info_0;
20538         TALLOC_CTX *_mem_save_info_0;
20539         if (flags & NDR_IN) {
20540                 ZERO_STRUCT(r->out);
20541
20542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20544         }
20545         if (flags & NDR_OUT) {
20546                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20547                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20549                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20550                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20551                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20552                 }
20553                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20554                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20555                 }
20556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20557         }
20558         return NDR_ERR_SUCCESS;
20559 }
20560
20561 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20562 {
20563         uint32_t cntr_info_2;
20564         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20565         ndr->depth++;
20566         if (flags & NDR_SET_VALUES) {
20567                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20568         }
20569         if (flags & NDR_IN) {
20570                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20571                 ndr->depth++;
20572                 ndr_print_ptr(ndr, "servername", r->in.servername);
20573                 ndr->depth++;
20574                 if (r->in.servername) {
20575                         ndr_print_string(ndr, "servername", r->in.servername);
20576                 }
20577                 ndr->depth--;
20578                 ndr_print_ptr(ndr, "environment", r->in.environment);
20579                 ndr->depth++;
20580                 if (r->in.environment) {
20581                         ndr_print_string(ndr, "environment", r->in.environment);
20582                 }
20583                 ndr->depth--;
20584                 ndr_print_uint32(ndr, "level", r->in.level);
20585                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20586                 ndr->depth++;
20587                 if (r->in.buffer) {
20588                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20589                 }
20590                 ndr->depth--;
20591                 ndr_print_uint32(ndr, "offered", r->in.offered);
20592                 ndr->depth--;
20593         }
20594         if (flags & NDR_OUT) {
20595                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20596                 ndr->depth++;
20597                 ndr_print_ptr(ndr, "count", r->out.count);
20598                 ndr->depth++;
20599                 ndr_print_uint32(ndr, "count", *r->out.count);
20600                 ndr->depth--;
20601                 ndr_print_ptr(ndr, "info", r->out.info);
20602                 ndr->depth++;
20603                 ndr_print_ptr(ndr, "info", *r->out.info);
20604                 ndr->depth++;
20605                 if (*r->out.info) {
20606                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20607                         ndr->depth++;
20608                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20609                                 char *idx_2=NULL;
20610                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20611                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20612                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20613                                         free(idx_2);
20614                                 }
20615                         }
20616                         ndr->depth--;
20617                 }
20618                 ndr->depth--;
20619                 ndr->depth--;
20620                 ndr_print_ptr(ndr, "needed", r->out.needed);
20621                 ndr->depth++;
20622                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20623                 ndr->depth--;
20624                 ndr_print_WERROR(ndr, "result", r->out.result);
20625                 ndr->depth--;
20626         }
20627         ndr->depth--;
20628 }
20629
20630 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20631 {
20632         if (flags & NDR_IN) {
20633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20634                 if (r->in.server) {
20635                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20638                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20639                 }
20640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20641                 if (r->in.environment) {
20642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20645                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20646                 }
20647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20649                 if (r->in.buffer) {
20650                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20651                 }
20652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20653         }
20654         if (flags & NDR_OUT) {
20655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20656                 if (r->out.info) {
20657                         {
20658                                 struct ndr_push *_ndr_info;
20659                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20660                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20661                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20662                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20663                         }
20664                 }
20665                 if (r->out.needed == NULL) {
20666                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20667                 }
20668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20669                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20670         }
20671         return NDR_ERR_SUCCESS;
20672 }
20673
20674 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20675 {
20676         uint32_t _ptr_server;
20677         uint32_t _ptr_environment;
20678         uint32_t _ptr_buffer;
20679         uint32_t _ptr_info;
20680         TALLOC_CTX *_mem_save_server_0;
20681         TALLOC_CTX *_mem_save_environment_0;
20682         TALLOC_CTX *_mem_save_buffer_0;
20683         TALLOC_CTX *_mem_save_info_0;
20684         TALLOC_CTX *_mem_save_needed_0;
20685         if (flags & NDR_IN) {
20686                 ZERO_STRUCT(r->out);
20687
20688                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20689                 if (_ptr_server) {
20690                         NDR_PULL_ALLOC(ndr, r->in.server);
20691                 } else {
20692                         r->in.server = NULL;
20693                 }
20694                 if (r->in.server) {
20695                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20696                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20697                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20698                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20699                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20700                                 return 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));
20701                         }
20702                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20703                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20704                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20705                 }
20706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20707                 if (_ptr_environment) {
20708                         NDR_PULL_ALLOC(ndr, r->in.environment);
20709                 } else {
20710                         r->in.environment = NULL;
20711                 }
20712                 if (r->in.environment) {
20713                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20714                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20715                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20716                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20717                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20718                                 return 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));
20719                         }
20720                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20721                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20722                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20723                 }
20724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20726                 if (_ptr_buffer) {
20727                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20728                 } else {
20729                         r->in.buffer = NULL;
20730                 }
20731                 if (r->in.buffer) {
20732                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20733                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20734                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20736                 }
20737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20738                 NDR_PULL_ALLOC(ndr, r->out.needed);
20739                 ZERO_STRUCTP(r->out.needed);
20740         }
20741         if (flags & NDR_OUT) {
20742                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20743                 if (_ptr_info) {
20744                         NDR_PULL_ALLOC(ndr, r->out.info);
20745                 } else {
20746                         r->out.info = NULL;
20747                 }
20748                 if (r->out.info) {
20749                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20750                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20751                         {
20752                                 struct ndr_pull *_ndr_info;
20753                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20754                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20755                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20756                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20757                         }
20758                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20759                 }
20760                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20761                         NDR_PULL_ALLOC(ndr, r->out.needed);
20762                 }
20763                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20764                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20766                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20768         }
20769         return NDR_ERR_SUCCESS;
20770 }
20771
20772 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20773 {
20774         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20775         ndr->depth++;
20776         if (flags & NDR_SET_VALUES) {
20777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20778         }
20779         if (flags & NDR_IN) {
20780                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20781                 ndr->depth++;
20782                 ndr_print_ptr(ndr, "server", r->in.server);
20783                 ndr->depth++;
20784                 if (r->in.server) {
20785                         ndr_print_string(ndr, "server", r->in.server);
20786                 }
20787                 ndr->depth--;
20788                 ndr_print_ptr(ndr, "environment", r->in.environment);
20789                 ndr->depth++;
20790                 if (r->in.environment) {
20791                         ndr_print_string(ndr, "environment", r->in.environment);
20792                 }
20793                 ndr->depth--;
20794                 ndr_print_uint32(ndr, "level", r->in.level);
20795                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20796                 ndr->depth++;
20797                 if (r->in.buffer) {
20798                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20799                 }
20800                 ndr->depth--;
20801                 ndr_print_uint32(ndr, "offered", r->in.offered);
20802                 ndr->depth--;
20803         }
20804         if (flags & NDR_OUT) {
20805                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20806                 ndr->depth++;
20807                 ndr_print_ptr(ndr, "info", r->out.info);
20808                 ndr->depth++;
20809                 if (r->out.info) {
20810                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20811                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20812                 }
20813                 ndr->depth--;
20814                 ndr_print_ptr(ndr, "needed", r->out.needed);
20815                 ndr->depth++;
20816                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20817                 ndr->depth--;
20818                 ndr_print_WERROR(ndr, "result", r->out.result);
20819                 ndr->depth--;
20820         }
20821         ndr->depth--;
20822 }
20823
20824 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20825 {
20826         if (flags & NDR_IN) {
20827                 if (r->in.handle == NULL) {
20828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20829                 }
20830                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20832                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20833                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20834         }
20835         if (flags & NDR_OUT) {
20836                 if (r->out.job_id == NULL) {
20837                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20838                 }
20839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20841         }
20842         return NDR_ERR_SUCCESS;
20843 }
20844
20845 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20846 {
20847         TALLOC_CTX *_mem_save_handle_0;
20848         TALLOC_CTX *_mem_save_job_id_0;
20849         if (flags & NDR_IN) {
20850                 ZERO_STRUCT(r->out);
20851
20852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20853                         NDR_PULL_ALLOC(ndr, r->in.handle);
20854                 }
20855                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20856                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20857                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20860                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20861                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20862                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20863                 ZERO_STRUCTP(r->out.job_id);
20864         }
20865         if (flags & NDR_OUT) {
20866                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20867                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20868                 }
20869                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20870                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20872                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20874         }
20875         return NDR_ERR_SUCCESS;
20876 }
20877
20878 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20879 {
20880         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20881         ndr->depth++;
20882         if (flags & NDR_SET_VALUES) {
20883                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20884         }
20885         if (flags & NDR_IN) {
20886                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20887                 ndr->depth++;
20888                 ndr_print_ptr(ndr, "handle", r->in.handle);
20889                 ndr->depth++;
20890                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20891                 ndr->depth--;
20892                 ndr_print_uint32(ndr, "level", r->in.level);
20893                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20894                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20895                 ndr->depth--;
20896         }
20897         if (flags & NDR_OUT) {
20898                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20899                 ndr->depth++;
20900                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20901                 ndr->depth++;
20902                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20903                 ndr->depth--;
20904                 ndr_print_WERROR(ndr, "result", r->out.result);
20905                 ndr->depth--;
20906         }
20907         ndr->depth--;
20908 }
20909
20910 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20911 {
20912         if (flags & NDR_IN) {
20913                 if (r->in.handle == NULL) {
20914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20915                 }
20916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20917         }
20918         if (flags & NDR_OUT) {
20919                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20920         }
20921         return NDR_ERR_SUCCESS;
20922 }
20923
20924 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20925 {
20926         TALLOC_CTX *_mem_save_handle_0;
20927         if (flags & NDR_IN) {
20928                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20929                         NDR_PULL_ALLOC(ndr, r->in.handle);
20930                 }
20931                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20932                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20933                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20934                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20935         }
20936         if (flags & NDR_OUT) {
20937                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20938         }
20939         return NDR_ERR_SUCCESS;
20940 }
20941
20942 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
20943 {
20944         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
20945         ndr->depth++;
20946         if (flags & NDR_SET_VALUES) {
20947                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20948         }
20949         if (flags & NDR_IN) {
20950                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
20951                 ndr->depth++;
20952                 ndr_print_ptr(ndr, "handle", r->in.handle);
20953                 ndr->depth++;
20954                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20955                 ndr->depth--;
20956                 ndr->depth--;
20957         }
20958         if (flags & NDR_OUT) {
20959                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
20960                 ndr->depth++;
20961                 ndr_print_WERROR(ndr, "result", r->out.result);
20962                 ndr->depth--;
20963         }
20964         ndr->depth--;
20965 }
20966
20967 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
20968 {
20969         if (flags & NDR_IN) {
20970                 if (r->in.handle == NULL) {
20971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20972                 }
20973                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20974                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
20975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
20976         }
20977         if (flags & NDR_OUT) {
20978                 if (r->out.num_written == NULL) {
20979                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20980                 }
20981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
20982                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20983         }
20984         return NDR_ERR_SUCCESS;
20985 }
20986
20987 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
20988 {
20989         TALLOC_CTX *_mem_save_handle_0;
20990         TALLOC_CTX *_mem_save_num_written_0;
20991         if (flags & NDR_IN) {
20992                 ZERO_STRUCT(r->out);
20993
20994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20995                         NDR_PULL_ALLOC(ndr, r->in.handle);
20996                 }
20997                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20998                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20999                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21001                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21003                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21004                 ZERO_STRUCTP(r->out.num_written);
21005         }
21006         if (flags & NDR_OUT) {
21007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21008                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21009                 }
21010                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21011                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21014                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21015         }
21016         return NDR_ERR_SUCCESS;
21017 }
21018
21019 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21020 {
21021         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21022         ndr->depth++;
21023         if (flags & NDR_SET_VALUES) {
21024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21025         }
21026         if (flags & NDR_IN) {
21027                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21028                 ndr->depth++;
21029                 ndr_print_ptr(ndr, "handle", r->in.handle);
21030                 ndr->depth++;
21031                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21032                 ndr->depth--;
21033                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21034                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21035                 ndr->depth--;
21036         }
21037         if (flags & NDR_OUT) {
21038                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21039                 ndr->depth++;
21040                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21041                 ndr->depth++;
21042                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21043                 ndr->depth--;
21044                 ndr_print_WERROR(ndr, "result", r->out.result);
21045                 ndr->depth--;
21046         }
21047         ndr->depth--;
21048 }
21049
21050 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21051 {
21052         if (flags & NDR_IN) {
21053                 if (r->in.handle == NULL) {
21054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21055                 }
21056                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21057         }
21058         if (flags & NDR_OUT) {
21059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21060         }
21061         return NDR_ERR_SUCCESS;
21062 }
21063
21064 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21065 {
21066         TALLOC_CTX *_mem_save_handle_0;
21067         if (flags & NDR_IN) {
21068                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21069                         NDR_PULL_ALLOC(ndr, r->in.handle);
21070                 }
21071                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21072                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21073                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21074                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21075         }
21076         if (flags & NDR_OUT) {
21077                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21078         }
21079         return NDR_ERR_SUCCESS;
21080 }
21081
21082 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21083 {
21084         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21085         ndr->depth++;
21086         if (flags & NDR_SET_VALUES) {
21087                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21088         }
21089         if (flags & NDR_IN) {
21090                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21091                 ndr->depth++;
21092                 ndr_print_ptr(ndr, "handle", r->in.handle);
21093                 ndr->depth++;
21094                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21095                 ndr->depth--;
21096                 ndr->depth--;
21097         }
21098         if (flags & NDR_OUT) {
21099                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21100                 ndr->depth++;
21101                 ndr_print_WERROR(ndr, "result", r->out.result);
21102                 ndr->depth--;
21103         }
21104         ndr->depth--;
21105 }
21106
21107 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21108 {
21109         if (flags & NDR_IN) {
21110                 if (r->in.handle == NULL) {
21111                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21112                 }
21113                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21114         }
21115         if (flags & NDR_OUT) {
21116                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21117         }
21118         return NDR_ERR_SUCCESS;
21119 }
21120
21121 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21122 {
21123         TALLOC_CTX *_mem_save_handle_0;
21124         if (flags & NDR_IN) {
21125                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21126                         NDR_PULL_ALLOC(ndr, r->in.handle);
21127                 }
21128                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21129                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21130                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21131                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21132         }
21133         if (flags & NDR_OUT) {
21134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21135         }
21136         return NDR_ERR_SUCCESS;
21137 }
21138
21139 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21140 {
21141         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21142         ndr->depth++;
21143         if (flags & NDR_SET_VALUES) {
21144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21145         }
21146         if (flags & NDR_IN) {
21147                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21148                 ndr->depth++;
21149                 ndr_print_ptr(ndr, "handle", r->in.handle);
21150                 ndr->depth++;
21151                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21152                 ndr->depth--;
21153                 ndr->depth--;
21154         }
21155         if (flags & NDR_OUT) {
21156                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21157                 ndr->depth++;
21158                 ndr_print_WERROR(ndr, "result", r->out.result);
21159                 ndr->depth--;
21160         }
21161         ndr->depth--;
21162 }
21163
21164 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21165 {
21166         if (flags & NDR_IN) {
21167                 if (r->in.handle == NULL) {
21168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21169                 }
21170                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21172         }
21173         if (flags & NDR_OUT) {
21174                 if (r->out.data == NULL) {
21175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21176                 }
21177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21178                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21179                 if (r->out._data_size == NULL) {
21180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21181                 }
21182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21184         }
21185         return NDR_ERR_SUCCESS;
21186 }
21187
21188 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21189 {
21190         TALLOC_CTX *_mem_save_handle_0;
21191         TALLOC_CTX *_mem_save__data_size_0;
21192         if (flags & NDR_IN) {
21193                 ZERO_STRUCT(r->out);
21194
21195                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21196                         NDR_PULL_ALLOC(ndr, r->in.handle);
21197                 }
21198                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21199                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21200                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21201                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21203                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21204                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21205                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21206                 ZERO_STRUCTP(r->out._data_size);
21207         }
21208         if (flags & NDR_OUT) {
21209                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21210                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21211                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21212                 }
21213                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21215                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21216                 }
21217                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21218                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21222                 if (r->out.data) {
21223                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21224                 }
21225         }
21226         return NDR_ERR_SUCCESS;
21227 }
21228
21229 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21230 {
21231         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21232         ndr->depth++;
21233         if (flags & NDR_SET_VALUES) {
21234                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21235         }
21236         if (flags & NDR_IN) {
21237                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21238                 ndr->depth++;
21239                 ndr_print_ptr(ndr, "handle", r->in.handle);
21240                 ndr->depth++;
21241                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21242                 ndr->depth--;
21243                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21244                 ndr->depth--;
21245         }
21246         if (flags & NDR_OUT) {
21247                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21248                 ndr->depth++;
21249                 ndr_print_ptr(ndr, "data", r->out.data);
21250                 ndr->depth++;
21251                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21252                 ndr->depth--;
21253                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21254                 ndr->depth++;
21255                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21256                 ndr->depth--;
21257                 ndr_print_WERROR(ndr, "result", r->out.result);
21258                 ndr->depth--;
21259         }
21260         ndr->depth--;
21261 }
21262
21263 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21264 {
21265         if (flags & NDR_IN) {
21266                 if (r->in.handle == NULL) {
21267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21268                 }
21269                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21270         }
21271         if (flags & NDR_OUT) {
21272                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21273         }
21274         return NDR_ERR_SUCCESS;
21275 }
21276
21277 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21278 {
21279         TALLOC_CTX *_mem_save_handle_0;
21280         if (flags & NDR_IN) {
21281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21282                         NDR_PULL_ALLOC(ndr, r->in.handle);
21283                 }
21284                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21285                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21286                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21288         }
21289         if (flags & NDR_OUT) {
21290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21291         }
21292         return NDR_ERR_SUCCESS;
21293 }
21294
21295 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21296 {
21297         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21298         ndr->depth++;
21299         if (flags & NDR_SET_VALUES) {
21300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21301         }
21302         if (flags & NDR_IN) {
21303                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21304                 ndr->depth++;
21305                 ndr_print_ptr(ndr, "handle", r->in.handle);
21306                 ndr->depth++;
21307                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21308                 ndr->depth--;
21309                 ndr->depth--;
21310         }
21311         if (flags & NDR_OUT) {
21312                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21313                 ndr->depth++;
21314                 ndr_print_WERROR(ndr, "result", r->out.result);
21315                 ndr->depth--;
21316         }
21317         ndr->depth--;
21318 }
21319
21320 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21321 {
21322         if (flags & NDR_IN) {
21323                 if (r->in.handle == NULL) {
21324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21325                 }
21326                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21329                 if (r->in.buffer) {
21330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21331                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21332                 }
21333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21334         }
21335         if (flags & NDR_OUT) {
21336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21337                 if (r->out.buffer) {
21338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21339                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21340                 }
21341                 if (r->out.needed == NULL) {
21342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21343                 }
21344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21346         }
21347         return NDR_ERR_SUCCESS;
21348 }
21349
21350 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21351 {
21352         uint32_t _ptr_buffer;
21353         TALLOC_CTX *_mem_save_handle_0;
21354         TALLOC_CTX *_mem_save_buffer_0;
21355         TALLOC_CTX *_mem_save_needed_0;
21356         if (flags & NDR_IN) {
21357                 ZERO_STRUCT(r->out);
21358
21359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21360                         NDR_PULL_ALLOC(ndr, r->in.handle);
21361                 }
21362                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21363                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21364                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21367                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21368                 if (_ptr_buffer) {
21369                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21370                 } else {
21371                         r->in.buffer = NULL;
21372                 }
21373                 if (r->in.buffer) {
21374                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21375                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21377                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21378                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21380                 }
21381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21382                 NDR_PULL_ALLOC(ndr, r->out.needed);
21383                 ZERO_STRUCTP(r->out.needed);
21384                 if (r->in.buffer) {
21385                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21386                 }
21387         }
21388         if (flags & NDR_OUT) {
21389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21390                 if (_ptr_buffer) {
21391                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21392                 } else {
21393                         r->out.buffer = NULL;
21394                 }
21395                 if (r->out.buffer) {
21396                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21397                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21398                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21399                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21400                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21402                 }
21403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21404                         NDR_PULL_ALLOC(ndr, r->out.needed);
21405                 }
21406                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21407                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21410                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21411                 if (r->out.buffer) {
21412                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21413                 }
21414         }
21415         return NDR_ERR_SUCCESS;
21416 }
21417
21418 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21419 {
21420         ndr_print_struct(ndr, name, "spoolss_AddJob");
21421         ndr->depth++;
21422         if (flags & NDR_SET_VALUES) {
21423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21424         }
21425         if (flags & NDR_IN) {
21426                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21427                 ndr->depth++;
21428                 ndr_print_ptr(ndr, "handle", r->in.handle);
21429                 ndr->depth++;
21430                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21431                 ndr->depth--;
21432                 ndr_print_uint32(ndr, "level", r->in.level);
21433                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21434                 ndr->depth++;
21435                 if (r->in.buffer) {
21436                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21437                 }
21438                 ndr->depth--;
21439                 ndr_print_uint32(ndr, "offered", r->in.offered);
21440                 ndr->depth--;
21441         }
21442         if (flags & NDR_OUT) {
21443                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21444                 ndr->depth++;
21445                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21446                 ndr->depth++;
21447                 if (r->out.buffer) {
21448                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21449                 }
21450                 ndr->depth--;
21451                 ndr_print_ptr(ndr, "needed", r->out.needed);
21452                 ndr->depth++;
21453                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21454                 ndr->depth--;
21455                 ndr_print_WERROR(ndr, "result", r->out.result);
21456                 ndr->depth--;
21457         }
21458         ndr->depth--;
21459 }
21460
21461 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21462 {
21463         if (flags & NDR_IN) {
21464                 if (r->in.handle == NULL) {
21465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21466                 }
21467                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21469         }
21470         if (flags & NDR_OUT) {
21471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21472         }
21473         return NDR_ERR_SUCCESS;
21474 }
21475
21476 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21477 {
21478         TALLOC_CTX *_mem_save_handle_0;
21479         if (flags & NDR_IN) {
21480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21481                         NDR_PULL_ALLOC(ndr, r->in.handle);
21482                 }
21483                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21484                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21488         }
21489         if (flags & NDR_OUT) {
21490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21491         }
21492         return NDR_ERR_SUCCESS;
21493 }
21494
21495 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21496 {
21497         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21498         ndr->depth++;
21499         if (flags & NDR_SET_VALUES) {
21500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21501         }
21502         if (flags & NDR_IN) {
21503                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21504                 ndr->depth++;
21505                 ndr_print_ptr(ndr, "handle", r->in.handle);
21506                 ndr->depth++;
21507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21508                 ndr->depth--;
21509                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21510                 ndr->depth--;
21511         }
21512         if (flags & NDR_OUT) {
21513                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21514                 ndr->depth++;
21515                 ndr_print_WERROR(ndr, "result", r->out.result);
21516                 ndr->depth--;
21517         }
21518         ndr->depth--;
21519 }
21520
21521 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21522 {
21523         if (flags & NDR_IN) {
21524                 if (r->in.handle == NULL) {
21525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21526                 }
21527                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21531                 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));
21532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21533         }
21534         if (flags & NDR_OUT) {
21535                 if (r->out.type == NULL) {
21536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21537                 }
21538                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
21539                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21540                 if (r->out.needed == NULL) {
21541                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21542                 }
21543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21544                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21545         }
21546         return NDR_ERR_SUCCESS;
21547 }
21548
21549 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21550 {
21551         TALLOC_CTX *_mem_save_handle_0;
21552         TALLOC_CTX *_mem_save_type_0;
21553         TALLOC_CTX *_mem_save_needed_0;
21554         if (flags & NDR_IN) {
21555                 ZERO_STRUCT(r->out);
21556
21557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21558                         NDR_PULL_ALLOC(ndr, r->in.handle);
21559                 }
21560                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21564                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21565                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21566                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21567                         return 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));
21568                 }
21569                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21570                 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));
21571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21572                 NDR_PULL_ALLOC(ndr, r->out.type);
21573                 ZERO_STRUCTP(r->out.type);
21574                 NDR_PULL_ALLOC(ndr, r->out.needed);
21575                 ZERO_STRUCTP(r->out.needed);
21576         }
21577         if (flags & NDR_OUT) {
21578                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21579                         NDR_PULL_ALLOC(ndr, r->out.type);
21580                 }
21581                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21582                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21583                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
21584                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21585                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
21586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21587                         NDR_PULL_ALLOC(ndr, r->out.needed);
21588                 }
21589                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21590                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21593                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21594         }
21595         return NDR_ERR_SUCCESS;
21596 }
21597
21598 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21599 {
21600         if (flags & NDR_IN) {
21601                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21602         }
21603         if (flags & NDR_OUT) {
21604                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21605                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21606         }
21607         return NDR_ERR_SUCCESS;
21608 }
21609
21610 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21611 {
21612         if (flags & NDR_IN) {
21613                 ZERO_STRUCT(r->out);
21614
21615                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21616         }
21617         if (flags & NDR_OUT) {
21618                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
21619                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21620         }
21621         return NDR_ERR_SUCCESS;
21622 }
21623
21624 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21625 {
21626         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21627         ndr->depth++;
21628         if (flags & NDR_SET_VALUES) {
21629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21630         }
21631         if (flags & NDR_IN) {
21632                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21633                 ndr->depth++;
21634                 ndr_print_ptr(ndr, "handle", r->in.handle);
21635                 ndr->depth++;
21636                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21637                 ndr->depth--;
21638                 ndr_print_string(ndr, "value_name", r->in.value_name);
21639                 ndr_print_uint32(ndr, "offered", r->in.offered);
21640                 ndr->depth--;
21641         }
21642         if (flags & NDR_OUT) {
21643                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21644                 ndr->depth++;
21645                 ndr_print_ptr(ndr, "type", r->out.type);
21646                 ndr->depth++;
21647                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
21648                 ndr->depth--;
21649                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
21650                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
21651                 ndr_print_ptr(ndr, "needed", r->out.needed);
21652                 ndr->depth++;
21653                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21654                 ndr->depth--;
21655                 ndr_print_WERROR(ndr, "result", r->out.result);
21656                 ndr->depth--;
21657         }
21658         ndr->depth--;
21659 }
21660
21661 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21662 {
21663         if (flags & NDR_IN) {
21664                 if (r->in.handle == NULL) {
21665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21666                 }
21667                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21671                 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));
21672                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21673                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21675         }
21676         if (flags & NDR_OUT) {
21677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21678         }
21679         return NDR_ERR_SUCCESS;
21680 }
21681
21682 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21683 {
21684         if (flags & NDR_IN) {
21685                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21686         }
21687         if (flags & NDR_OUT) {
21688                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21689                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21690         }
21691         return NDR_ERR_SUCCESS;
21692 }
21693
21694 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21695 {
21696         TALLOC_CTX *_mem_save_handle_0;
21697         if (flags & NDR_IN) {
21698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21699                         NDR_PULL_ALLOC(ndr, r->in.handle);
21700                 }
21701                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21702                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21703                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21705                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21706                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21707                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21708                         return 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));
21709                 }
21710                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21711                 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));
21712                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21713                 {
21714                         struct ndr_pull *_ndr_data;
21715                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21716                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21717                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21718                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21719                 }
21720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21721         }
21722         if (flags & NDR_OUT) {
21723                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21724         }
21725         return NDR_ERR_SUCCESS;
21726 }
21727
21728 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21729 {
21730         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21731         ndr->depth++;
21732         if (flags & NDR_SET_VALUES) {
21733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21734         }
21735         if (flags & NDR_IN) {
21736                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21737                 ndr->depth++;
21738                 ndr_print_ptr(ndr, "handle", r->in.handle);
21739                 ndr->depth++;
21740                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21741                 ndr->depth--;
21742                 ndr_print_string(ndr, "value_name", r->in.value_name);
21743                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
21744                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21745                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21746                 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);
21747                 ndr->depth--;
21748         }
21749         if (flags & NDR_OUT) {
21750                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21751                 ndr->depth++;
21752                 ndr_print_WERROR(ndr, "result", r->out.result);
21753                 ndr->depth--;
21754         }
21755         ndr->depth--;
21756 }
21757
21758 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21759 {
21760         if (flags & NDR_IN) {
21761         }
21762         if (flags & NDR_OUT) {
21763                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21764         }
21765         return NDR_ERR_SUCCESS;
21766 }
21767
21768 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21769 {
21770         if (flags & NDR_IN) {
21771         }
21772         if (flags & NDR_OUT) {
21773                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21774         }
21775         return NDR_ERR_SUCCESS;
21776 }
21777
21778 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21779 {
21780         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21781         ndr->depth++;
21782         if (flags & NDR_SET_VALUES) {
21783                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21784         }
21785         if (flags & NDR_IN) {
21786                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21787                 ndr->depth++;
21788                 ndr->depth--;
21789         }
21790         if (flags & NDR_OUT) {
21791                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21792                 ndr->depth++;
21793                 ndr_print_WERROR(ndr, "result", r->out.result);
21794                 ndr->depth--;
21795         }
21796         ndr->depth--;
21797 }
21798
21799 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21800 {
21801         if (flags & NDR_IN) {
21802                 if (r->in.handle == NULL) {
21803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21804                 }
21805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21806         }
21807         if (flags & NDR_OUT) {
21808                 if (r->out.handle == NULL) {
21809                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21810                 }
21811                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21812                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21813         }
21814         return NDR_ERR_SUCCESS;
21815 }
21816
21817 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21818 {
21819         TALLOC_CTX *_mem_save_handle_0;
21820         if (flags & NDR_IN) {
21821                 ZERO_STRUCT(r->out);
21822
21823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21824                         NDR_PULL_ALLOC(ndr, r->in.handle);
21825                 }
21826                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21827                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21828                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21830                 NDR_PULL_ALLOC(ndr, r->out.handle);
21831                 *r->out.handle = *r->in.handle;
21832         }
21833         if (flags & NDR_OUT) {
21834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21835                         NDR_PULL_ALLOC(ndr, r->out.handle);
21836                 }
21837                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21838                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21839                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21841                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21842         }
21843         return NDR_ERR_SUCCESS;
21844 }
21845
21846 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21847 {
21848         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21849         ndr->depth++;
21850         if (flags & NDR_SET_VALUES) {
21851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21852         }
21853         if (flags & NDR_IN) {
21854                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21855                 ndr->depth++;
21856                 ndr_print_ptr(ndr, "handle", r->in.handle);
21857                 ndr->depth++;
21858                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21859                 ndr->depth--;
21860                 ndr->depth--;
21861         }
21862         if (flags & NDR_OUT) {
21863                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21864                 ndr->depth++;
21865                 ndr_print_ptr(ndr, "handle", r->out.handle);
21866                 ndr->depth++;
21867                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21868                 ndr->depth--;
21869                 ndr_print_WERROR(ndr, "result", r->out.result);
21870                 ndr->depth--;
21871         }
21872         ndr->depth--;
21873 }
21874
21875 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21876 {
21877         if (flags & NDR_IN) {
21878                 if (r->in.handle == NULL) {
21879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21880                 }
21881                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21883                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21884                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21885         }
21886         if (flags & NDR_OUT) {
21887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21888         }
21889         return NDR_ERR_SUCCESS;
21890 }
21891
21892 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21893 {
21894         TALLOC_CTX *_mem_save_handle_0;
21895         if (flags & NDR_IN) {
21896                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21897                         NDR_PULL_ALLOC(ndr, r->in.handle);
21898                 }
21899                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21900                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21901                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21904                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21905                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21906         }
21907         if (flags & NDR_OUT) {
21908                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21909         }
21910         return NDR_ERR_SUCCESS;
21911 }
21912
21913 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21914 {
21915         ndr_print_struct(ndr, name, "spoolss_AddForm");
21916         ndr->depth++;
21917         if (flags & NDR_SET_VALUES) {
21918                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21919         }
21920         if (flags & NDR_IN) {
21921                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21922                 ndr->depth++;
21923                 ndr_print_ptr(ndr, "handle", r->in.handle);
21924                 ndr->depth++;
21925                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21926                 ndr->depth--;
21927                 ndr_print_uint32(ndr, "level", r->in.level);
21928                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21929                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
21930                 ndr->depth--;
21931         }
21932         if (flags & NDR_OUT) {
21933                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
21934                 ndr->depth++;
21935                 ndr_print_WERROR(ndr, "result", r->out.result);
21936                 ndr->depth--;
21937         }
21938         ndr->depth--;
21939 }
21940
21941 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
21942 {
21943         if (flags & NDR_IN) {
21944                 if (r->in.handle == NULL) {
21945                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21946                 }
21947                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21951                 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));
21952         }
21953         if (flags & NDR_OUT) {
21954                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21955         }
21956         return NDR_ERR_SUCCESS;
21957 }
21958
21959 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
21960 {
21961         TALLOC_CTX *_mem_save_handle_0;
21962         if (flags & NDR_IN) {
21963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21964                         NDR_PULL_ALLOC(ndr, r->in.handle);
21965                 }
21966                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21967                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21968                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21970                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
21971                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
21972                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
21973                         return 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));
21974                 }
21975                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
21976                 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));
21977         }
21978         if (flags & NDR_OUT) {
21979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21980         }
21981         return NDR_ERR_SUCCESS;
21982 }
21983
21984 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
21985 {
21986         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
21987         ndr->depth++;
21988         if (flags & NDR_SET_VALUES) {
21989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21990         }
21991         if (flags & NDR_IN) {
21992                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
21993                 ndr->depth++;
21994                 ndr_print_ptr(ndr, "handle", r->in.handle);
21995                 ndr->depth++;
21996                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21997                 ndr->depth--;
21998                 ndr_print_string(ndr, "form_name", r->in.form_name);
21999                 ndr->depth--;
22000         }
22001         if (flags & NDR_OUT) {
22002                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22003                 ndr->depth++;
22004                 ndr_print_WERROR(ndr, "result", r->out.result);
22005                 ndr->depth--;
22006         }
22007         ndr->depth--;
22008 }
22009
22010 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22011 {
22012         if (flags & NDR_IN) {
22013                 if (r->in.handle == NULL) {
22014                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22015                 }
22016                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22020                 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));
22021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22023                 if (r->in.buffer) {
22024                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22025                 }
22026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22027         }
22028         if (flags & NDR_OUT) {
22029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22030                 if (r->out.info) {
22031                         {
22032                                 struct ndr_push *_ndr_info;
22033                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22034                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22035                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22036                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22037                         }
22038                 }
22039                 if (r->out.needed == NULL) {
22040                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22041                 }
22042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22043                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22044         }
22045         return NDR_ERR_SUCCESS;
22046 }
22047
22048 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22049 {
22050         uint32_t _ptr_buffer;
22051         uint32_t _ptr_info;
22052         TALLOC_CTX *_mem_save_handle_0;
22053         TALLOC_CTX *_mem_save_buffer_0;
22054         TALLOC_CTX *_mem_save_info_0;
22055         TALLOC_CTX *_mem_save_needed_0;
22056         if (flags & NDR_IN) {
22057                 ZERO_STRUCT(r->out);
22058
22059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22060                         NDR_PULL_ALLOC(ndr, r->in.handle);
22061                 }
22062                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22063                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22064                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22066                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22067                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22068                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22069                         return 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));
22070                 }
22071                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22072                 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));
22073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22074                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22075                 if (_ptr_buffer) {
22076                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22077                 } else {
22078                         r->in.buffer = NULL;
22079                 }
22080                 if (r->in.buffer) {
22081                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22082                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22083                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22085                 }
22086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22087                 NDR_PULL_ALLOC(ndr, r->out.needed);
22088                 ZERO_STRUCTP(r->out.needed);
22089         }
22090         if (flags & NDR_OUT) {
22091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22092                 if (_ptr_info) {
22093                         NDR_PULL_ALLOC(ndr, r->out.info);
22094                 } else {
22095                         r->out.info = NULL;
22096                 }
22097                 if (r->out.info) {
22098                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22099                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22100                         {
22101                                 struct ndr_pull *_ndr_info;
22102                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22103                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22104                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22105                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22106                         }
22107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22108                 }
22109                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22110                         NDR_PULL_ALLOC(ndr, r->out.needed);
22111                 }
22112                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22113                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22116                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22117         }
22118         return NDR_ERR_SUCCESS;
22119 }
22120
22121 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22122 {
22123         ndr_print_struct(ndr, name, "spoolss_GetForm");
22124         ndr->depth++;
22125         if (flags & NDR_SET_VALUES) {
22126                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22127         }
22128         if (flags & NDR_IN) {
22129                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22130                 ndr->depth++;
22131                 ndr_print_ptr(ndr, "handle", r->in.handle);
22132                 ndr->depth++;
22133                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22134                 ndr->depth--;
22135                 ndr_print_string(ndr, "form_name", r->in.form_name);
22136                 ndr_print_uint32(ndr, "level", r->in.level);
22137                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22138                 ndr->depth++;
22139                 if (r->in.buffer) {
22140                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22141                 }
22142                 ndr->depth--;
22143                 ndr_print_uint32(ndr, "offered", r->in.offered);
22144                 ndr->depth--;
22145         }
22146         if (flags & NDR_OUT) {
22147                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22148                 ndr->depth++;
22149                 ndr_print_ptr(ndr, "info", r->out.info);
22150                 ndr->depth++;
22151                 if (r->out.info) {
22152                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22153                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22154                 }
22155                 ndr->depth--;
22156                 ndr_print_ptr(ndr, "needed", r->out.needed);
22157                 ndr->depth++;
22158                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22159                 ndr->depth--;
22160                 ndr_print_WERROR(ndr, "result", r->out.result);
22161                 ndr->depth--;
22162         }
22163         ndr->depth--;
22164 }
22165
22166 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22167 {
22168         if (flags & NDR_IN) {
22169                 if (r->in.handle == NULL) {
22170                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22171                 }
22172                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22176                 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));
22177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22178                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22179                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22180         }
22181         if (flags & NDR_OUT) {
22182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22183         }
22184         return NDR_ERR_SUCCESS;
22185 }
22186
22187 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22188 {
22189         TALLOC_CTX *_mem_save_handle_0;
22190         if (flags & NDR_IN) {
22191                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22192                         NDR_PULL_ALLOC(ndr, r->in.handle);
22193                 }
22194                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22195                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22196                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22198                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22199                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22200                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22201                         return 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));
22202                 }
22203                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22204                 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));
22205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22206                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22207                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22208         }
22209         if (flags & NDR_OUT) {
22210                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22211         }
22212         return NDR_ERR_SUCCESS;
22213 }
22214
22215 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22216 {
22217         ndr_print_struct(ndr, name, "spoolss_SetForm");
22218         ndr->depth++;
22219         if (flags & NDR_SET_VALUES) {
22220                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22221         }
22222         if (flags & NDR_IN) {
22223                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22224                 ndr->depth++;
22225                 ndr_print_ptr(ndr, "handle", r->in.handle);
22226                 ndr->depth++;
22227                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22228                 ndr->depth--;
22229                 ndr_print_string(ndr, "form_name", r->in.form_name);
22230                 ndr_print_uint32(ndr, "level", r->in.level);
22231                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22232                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22233                 ndr->depth--;
22234         }
22235         if (flags & NDR_OUT) {
22236                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22237                 ndr->depth++;
22238                 ndr_print_WERROR(ndr, "result", r->out.result);
22239                 ndr->depth--;
22240         }
22241         ndr->depth--;
22242 }
22243
22244 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22245 {
22246         if (flags & NDR_IN) {
22247                 if (r->in.handle == NULL) {
22248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22249                 }
22250                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22253                 if (r->in.buffer) {
22254                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22255                 }
22256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22257         }
22258         if (flags & NDR_OUT) {
22259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22260                 if (r->out.info) {
22261                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22262                 }
22263                 if (r->out.needed == NULL) {
22264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22265                 }
22266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22267                 if (r->out.count == NULL) {
22268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22269                 }
22270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22272         }
22273         return NDR_ERR_SUCCESS;
22274 }
22275
22276 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22277 {
22278         uint32_t _ptr_buffer;
22279         uint32_t _ptr_info;
22280         TALLOC_CTX *_mem_save_handle_0;
22281         TALLOC_CTX *_mem_save_buffer_0;
22282         TALLOC_CTX *_mem_save_info_0;
22283         TALLOC_CTX *_mem_save_needed_0;
22284         TALLOC_CTX *_mem_save_count_0;
22285         if (flags & NDR_IN) {
22286                 ZERO_STRUCT(r->out);
22287
22288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22289                         NDR_PULL_ALLOC(ndr, r->in.handle);
22290                 }
22291                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22292                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22293                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22297                 if (_ptr_buffer) {
22298                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22299                 } else {
22300                         r->in.buffer = NULL;
22301                 }
22302                 if (r->in.buffer) {
22303                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22304                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22305                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22307                 }
22308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22309                 NDR_PULL_ALLOC(ndr, r->out.needed);
22310                 ZERO_STRUCTP(r->out.needed);
22311                 NDR_PULL_ALLOC(ndr, r->out.count);
22312                 ZERO_STRUCTP(r->out.count);
22313         }
22314         if (flags & NDR_OUT) {
22315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22316                 if (_ptr_info) {
22317                         NDR_PULL_ALLOC(ndr, r->out.info);
22318                 } else {
22319                         r->out.info = NULL;
22320                 }
22321                 if (r->out.info) {
22322                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22323                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22324                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22326                 }
22327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22328                         NDR_PULL_ALLOC(ndr, r->out.needed);
22329                 }
22330                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22335                         NDR_PULL_ALLOC(ndr, r->out.count);
22336                 }
22337                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22342         }
22343         return NDR_ERR_SUCCESS;
22344 }
22345
22346 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22347 {
22348         uint32_t cntr_info_0;
22349         if (flags & NDR_IN) {
22350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22352         }
22353         if (flags & NDR_OUT) {
22354                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22355                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22356                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22357                 }
22358                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22359                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22360                 }
22361         }
22362         return NDR_ERR_SUCCESS;
22363 }
22364
22365 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22366 {
22367         uint32_t cntr_info_0;
22368         TALLOC_CTX *_mem_save_info_0;
22369         if (flags & NDR_IN) {
22370                 ZERO_STRUCT(r->out);
22371
22372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22374         }
22375         if (flags & NDR_OUT) {
22376                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22377                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22378                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22379                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22380                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22381                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22382                 }
22383                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22384                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22385                 }
22386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22387         }
22388         return NDR_ERR_SUCCESS;
22389 }
22390
22391 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22392 {
22393         uint32_t cntr_info_2;
22394         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22395         ndr->depth++;
22396         if (flags & NDR_SET_VALUES) {
22397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22398         }
22399         if (flags & NDR_IN) {
22400                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22401                 ndr->depth++;
22402                 ndr_print_ptr(ndr, "handle", r->in.handle);
22403                 ndr->depth++;
22404                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22405                 ndr->depth--;
22406                 ndr_print_uint32(ndr, "level", r->in.level);
22407                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22408                 ndr->depth++;
22409                 if (r->in.buffer) {
22410                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22411                 }
22412                 ndr->depth--;
22413                 ndr_print_uint32(ndr, "offered", r->in.offered);
22414                 ndr->depth--;
22415         }
22416         if (flags & NDR_OUT) {
22417                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22418                 ndr->depth++;
22419                 ndr_print_ptr(ndr, "count", r->out.count);
22420                 ndr->depth++;
22421                 ndr_print_uint32(ndr, "count", *r->out.count);
22422                 ndr->depth--;
22423                 ndr_print_ptr(ndr, "info", r->out.info);
22424                 ndr->depth++;
22425                 ndr_print_ptr(ndr, "info", *r->out.info);
22426                 ndr->depth++;
22427                 if (*r->out.info) {
22428                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22429                         ndr->depth++;
22430                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22431                                 char *idx_2=NULL;
22432                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22433                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22434                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22435                                         free(idx_2);
22436                                 }
22437                         }
22438                         ndr->depth--;
22439                 }
22440                 ndr->depth--;
22441                 ndr->depth--;
22442                 ndr_print_ptr(ndr, "needed", r->out.needed);
22443                 ndr->depth++;
22444                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22445                 ndr->depth--;
22446                 ndr_print_WERROR(ndr, "result", r->out.result);
22447                 ndr->depth--;
22448         }
22449         ndr->depth--;
22450 }
22451
22452 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22453 {
22454         if (flags & NDR_IN) {
22455                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22456                 if (r->in.servername) {
22457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22461                 }
22462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22464                 if (r->in.buffer) {
22465                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22466                 }
22467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22468         }
22469         if (flags & NDR_OUT) {
22470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22471                 if (r->out.info) {
22472                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22473                 }
22474                 if (r->out.needed == NULL) {
22475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22476                 }
22477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22478                 if (r->out.count == NULL) {
22479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22480                 }
22481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22482                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22483         }
22484         return NDR_ERR_SUCCESS;
22485 }
22486
22487 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22488 {
22489         uint32_t _ptr_servername;
22490         uint32_t _ptr_buffer;
22491         uint32_t _ptr_info;
22492         TALLOC_CTX *_mem_save_servername_0;
22493         TALLOC_CTX *_mem_save_buffer_0;
22494         TALLOC_CTX *_mem_save_info_0;
22495         TALLOC_CTX *_mem_save_needed_0;
22496         TALLOC_CTX *_mem_save_count_0;
22497         if (flags & NDR_IN) {
22498                 ZERO_STRUCT(r->out);
22499
22500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22501                 if (_ptr_servername) {
22502                         NDR_PULL_ALLOC(ndr, r->in.servername);
22503                 } else {
22504                         r->in.servername = NULL;
22505                 }
22506                 if (r->in.servername) {
22507                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22508                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22511                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22512                                 return 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));
22513                         }
22514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22517                 }
22518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22520                 if (_ptr_buffer) {
22521                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22522                 } else {
22523                         r->in.buffer = NULL;
22524                 }
22525                 if (r->in.buffer) {
22526                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22527                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22528                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22530                 }
22531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22532                 NDR_PULL_ALLOC(ndr, r->out.needed);
22533                 ZERO_STRUCTP(r->out.needed);
22534                 NDR_PULL_ALLOC(ndr, r->out.count);
22535                 ZERO_STRUCTP(r->out.count);
22536         }
22537         if (flags & NDR_OUT) {
22538                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22539                 if (_ptr_info) {
22540                         NDR_PULL_ALLOC(ndr, r->out.info);
22541                 } else {
22542                         r->out.info = NULL;
22543                 }
22544                 if (r->out.info) {
22545                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22546                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22547                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22549                 }
22550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22551                         NDR_PULL_ALLOC(ndr, r->out.needed);
22552                 }
22553                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22558                         NDR_PULL_ALLOC(ndr, r->out.count);
22559                 }
22560                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22561                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22564                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22565         }
22566         return NDR_ERR_SUCCESS;
22567 }
22568
22569 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22570 {
22571         uint32_t cntr_info_0;
22572         if (flags & NDR_IN) {
22573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22575         }
22576         if (flags & NDR_OUT) {
22577                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22578                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22579                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22580                 }
22581                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22582                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22583                 }
22584         }
22585         return NDR_ERR_SUCCESS;
22586 }
22587
22588 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22589 {
22590         uint32_t cntr_info_0;
22591         TALLOC_CTX *_mem_save_info_0;
22592         if (flags & NDR_IN) {
22593                 ZERO_STRUCT(r->out);
22594
22595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22597         }
22598         if (flags & NDR_OUT) {
22599                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22600                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22601                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22602                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22603                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22604                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22605                 }
22606                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22607                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22608                 }
22609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22610         }
22611         return NDR_ERR_SUCCESS;
22612 }
22613
22614 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22615 {
22616         uint32_t cntr_info_2;
22617         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22618         ndr->depth++;
22619         if (flags & NDR_SET_VALUES) {
22620                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22621         }
22622         if (flags & NDR_IN) {
22623                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22624                 ndr->depth++;
22625                 ndr_print_ptr(ndr, "servername", r->in.servername);
22626                 ndr->depth++;
22627                 if (r->in.servername) {
22628                         ndr_print_string(ndr, "servername", r->in.servername);
22629                 }
22630                 ndr->depth--;
22631                 ndr_print_uint32(ndr, "level", r->in.level);
22632                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22633                 ndr->depth++;
22634                 if (r->in.buffer) {
22635                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22636                 }
22637                 ndr->depth--;
22638                 ndr_print_uint32(ndr, "offered", r->in.offered);
22639                 ndr->depth--;
22640         }
22641         if (flags & NDR_OUT) {
22642                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22643                 ndr->depth++;
22644                 ndr_print_ptr(ndr, "count", r->out.count);
22645                 ndr->depth++;
22646                 ndr_print_uint32(ndr, "count", *r->out.count);
22647                 ndr->depth--;
22648                 ndr_print_ptr(ndr, "info", r->out.info);
22649                 ndr->depth++;
22650                 ndr_print_ptr(ndr, "info", *r->out.info);
22651                 ndr->depth++;
22652                 if (*r->out.info) {
22653                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22654                         ndr->depth++;
22655                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22656                                 char *idx_2=NULL;
22657                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22658                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22659                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22660                                         free(idx_2);
22661                                 }
22662                         }
22663                         ndr->depth--;
22664                 }
22665                 ndr->depth--;
22666                 ndr->depth--;
22667                 ndr_print_ptr(ndr, "needed", r->out.needed);
22668                 ndr->depth++;
22669                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22670                 ndr->depth--;
22671                 ndr_print_WERROR(ndr, "result", r->out.result);
22672                 ndr->depth--;
22673         }
22674         ndr->depth--;
22675 }
22676
22677 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22678 {
22679         if (flags & NDR_IN) {
22680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22681                 if (r->in.servername) {
22682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22685                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22686                 }
22687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22689                 if (r->in.buffer) {
22690                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22691                 }
22692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22693         }
22694         if (flags & NDR_OUT) {
22695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22696                 if (r->out.info) {
22697                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22698                 }
22699                 if (r->out.needed == NULL) {
22700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22701                 }
22702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22703                 if (r->out.count == NULL) {
22704                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22705                 }
22706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22707                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22708         }
22709         return NDR_ERR_SUCCESS;
22710 }
22711
22712 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22713 {
22714         uint32_t _ptr_servername;
22715         uint32_t _ptr_buffer;
22716         uint32_t _ptr_info;
22717         TALLOC_CTX *_mem_save_servername_0;
22718         TALLOC_CTX *_mem_save_buffer_0;
22719         TALLOC_CTX *_mem_save_info_0;
22720         TALLOC_CTX *_mem_save_needed_0;
22721         TALLOC_CTX *_mem_save_count_0;
22722         if (flags & NDR_IN) {
22723                 ZERO_STRUCT(r->out);
22724
22725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22726                 if (_ptr_servername) {
22727                         NDR_PULL_ALLOC(ndr, r->in.servername);
22728                 } else {
22729                         r->in.servername = NULL;
22730                 }
22731                 if (r->in.servername) {
22732                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22733                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22735                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22736                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22737                                 return 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));
22738                         }
22739                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22740                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22742                 }
22743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22745                 if (_ptr_buffer) {
22746                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22747                 } else {
22748                         r->in.buffer = NULL;
22749                 }
22750                 if (r->in.buffer) {
22751                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22752                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22753                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22755                 }
22756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22757                 NDR_PULL_ALLOC(ndr, r->out.needed);
22758                 ZERO_STRUCTP(r->out.needed);
22759                 NDR_PULL_ALLOC(ndr, r->out.count);
22760                 ZERO_STRUCTP(r->out.count);
22761         }
22762         if (flags & NDR_OUT) {
22763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22764                 if (_ptr_info) {
22765                         NDR_PULL_ALLOC(ndr, r->out.info);
22766                 } else {
22767                         r->out.info = NULL;
22768                 }
22769                 if (r->out.info) {
22770                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22771                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22772                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22774                 }
22775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22776                         NDR_PULL_ALLOC(ndr, r->out.needed);
22777                 }
22778                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22779                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22782                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22783                         NDR_PULL_ALLOC(ndr, r->out.count);
22784                 }
22785                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22786                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22788                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22789                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22790         }
22791         return NDR_ERR_SUCCESS;
22792 }
22793
22794 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22795 {
22796         uint32_t cntr_info_0;
22797         if (flags & NDR_IN) {
22798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22800         }
22801         if (flags & NDR_OUT) {
22802                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22803                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22804                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22805                 }
22806                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22807                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22808                 }
22809         }
22810         return NDR_ERR_SUCCESS;
22811 }
22812
22813 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22814 {
22815         uint32_t cntr_info_0;
22816         TALLOC_CTX *_mem_save_info_0;
22817         if (flags & NDR_IN) {
22818                 ZERO_STRUCT(r->out);
22819
22820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22822         }
22823         if (flags & NDR_OUT) {
22824                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22825                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22826                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22827                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22828                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22829                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22830                 }
22831                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22832                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22833                 }
22834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22835         }
22836         return NDR_ERR_SUCCESS;
22837 }
22838
22839 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22840 {
22841         uint32_t cntr_info_2;
22842         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22843         ndr->depth++;
22844         if (flags & NDR_SET_VALUES) {
22845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22846         }
22847         if (flags & NDR_IN) {
22848                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22849                 ndr->depth++;
22850                 ndr_print_ptr(ndr, "servername", r->in.servername);
22851                 ndr->depth++;
22852                 if (r->in.servername) {
22853                         ndr_print_string(ndr, "servername", r->in.servername);
22854                 }
22855                 ndr->depth--;
22856                 ndr_print_uint32(ndr, "level", r->in.level);
22857                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22858                 ndr->depth++;
22859                 if (r->in.buffer) {
22860                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22861                 }
22862                 ndr->depth--;
22863                 ndr_print_uint32(ndr, "offered", r->in.offered);
22864                 ndr->depth--;
22865         }
22866         if (flags & NDR_OUT) {
22867                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22868                 ndr->depth++;
22869                 ndr_print_ptr(ndr, "count", r->out.count);
22870                 ndr->depth++;
22871                 ndr_print_uint32(ndr, "count", *r->out.count);
22872                 ndr->depth--;
22873                 ndr_print_ptr(ndr, "info", r->out.info);
22874                 ndr->depth++;
22875                 ndr_print_ptr(ndr, "info", *r->out.info);
22876                 ndr->depth++;
22877                 if (*r->out.info) {
22878                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22879                         ndr->depth++;
22880                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22881                                 char *idx_2=NULL;
22882                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22883                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22884                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22885                                         free(idx_2);
22886                                 }
22887                         }
22888                         ndr->depth--;
22889                 }
22890                 ndr->depth--;
22891                 ndr->depth--;
22892                 ndr_print_ptr(ndr, "needed", r->out.needed);
22893                 ndr->depth++;
22894                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22895                 ndr->depth--;
22896                 ndr_print_WERROR(ndr, "result", r->out.result);
22897                 ndr->depth--;
22898         }
22899         ndr->depth--;
22900 }
22901
22902 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22903 {
22904         if (flags & NDR_IN) {
22905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22906                 if (r->in.server_name) {
22907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22910                         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));
22911                 }
22912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22916                 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));
22917         }
22918         if (flags & NDR_OUT) {
22919                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22920         }
22921         return NDR_ERR_SUCCESS;
22922 }
22923
22924 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
22925 {
22926         uint32_t _ptr_server_name;
22927         TALLOC_CTX *_mem_save_server_name_0;
22928         if (flags & NDR_IN) {
22929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
22930                 if (_ptr_server_name) {
22931                         NDR_PULL_ALLOC(ndr, r->in.server_name);
22932                 } else {
22933                         r->in.server_name = NULL;
22934                 }
22935                 if (r->in.server_name) {
22936                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
22937                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
22938                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
22939                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
22940                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
22941                                 return 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));
22942                         }
22943                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
22944                         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));
22945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
22946                 }
22947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
22948                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
22949                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
22950                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
22951                         return 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));
22952                 }
22953                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
22954                 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));
22955         }
22956         if (flags & NDR_OUT) {
22957                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22958         }
22959         return NDR_ERR_SUCCESS;
22960 }
22961
22962 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
22963 {
22964         ndr_print_struct(ndr, name, "spoolss_AddPort");
22965         ndr->depth++;
22966         if (flags & NDR_SET_VALUES) {
22967                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22968         }
22969         if (flags & NDR_IN) {
22970                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
22971                 ndr->depth++;
22972                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
22973                 ndr->depth++;
22974                 if (r->in.server_name) {
22975                         ndr_print_string(ndr, "server_name", r->in.server_name);
22976                 }
22977                 ndr->depth--;
22978                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
22979                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
22980                 ndr->depth--;
22981         }
22982         if (flags & NDR_OUT) {
22983                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
22984                 ndr->depth++;
22985                 ndr_print_WERROR(ndr, "result", r->out.result);
22986                 ndr->depth--;
22987         }
22988         ndr->depth--;
22989 }
22990
22991 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
22992 {
22993         if (flags & NDR_IN) {
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_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23002 {
23003         if (flags & NDR_IN) {
23004         }
23005         if (flags & NDR_OUT) {
23006                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23007         }
23008         return NDR_ERR_SUCCESS;
23009 }
23010
23011 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23012 {
23013         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23014         ndr->depth++;
23015         if (flags & NDR_SET_VALUES) {
23016                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23017         }
23018         if (flags & NDR_IN) {
23019                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23020                 ndr->depth++;
23021                 ndr->depth--;
23022         }
23023         if (flags & NDR_OUT) {
23024                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23025                 ndr->depth++;
23026                 ndr_print_WERROR(ndr, "result", r->out.result);
23027                 ndr->depth--;
23028         }
23029         ndr->depth--;
23030 }
23031
23032 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23033 {
23034         if (flags & NDR_IN) {
23035         }
23036         if (flags & NDR_OUT) {
23037                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23038         }
23039         return NDR_ERR_SUCCESS;
23040 }
23041
23042 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23043 {
23044         if (flags & NDR_IN) {
23045         }
23046         if (flags & NDR_OUT) {
23047                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23048         }
23049         return NDR_ERR_SUCCESS;
23050 }
23051
23052 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23053 {
23054         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23055         ndr->depth++;
23056         if (flags & NDR_SET_VALUES) {
23057                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23058         }
23059         if (flags & NDR_IN) {
23060                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23061                 ndr->depth++;
23062                 ndr->depth--;
23063         }
23064         if (flags & NDR_OUT) {
23065                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23066                 ndr->depth++;
23067                 ndr_print_WERROR(ndr, "result", r->out.result);
23068                 ndr->depth--;
23069         }
23070         ndr->depth--;
23071 }
23072
23073 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23074 {
23075         if (flags & NDR_IN) {
23076         }
23077         if (flags & NDR_OUT) {
23078                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23079         }
23080         return NDR_ERR_SUCCESS;
23081 }
23082
23083 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23084 {
23085         if (flags & NDR_IN) {
23086         }
23087         if (flags & NDR_OUT) {
23088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23089         }
23090         return NDR_ERR_SUCCESS;
23091 }
23092
23093 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23094 {
23095         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23096         ndr->depth++;
23097         if (flags & NDR_SET_VALUES) {
23098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23099         }
23100         if (flags & NDR_IN) {
23101                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23102                 ndr->depth++;
23103                 ndr->depth--;
23104         }
23105         if (flags & NDR_OUT) {
23106                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23107                 ndr->depth++;
23108                 ndr_print_WERROR(ndr, "result", r->out.result);
23109                 ndr->depth--;
23110         }
23111         ndr->depth--;
23112 }
23113
23114 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23115 {
23116         if (flags & NDR_IN) {
23117         }
23118         if (flags & NDR_OUT) {
23119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23120         }
23121         return NDR_ERR_SUCCESS;
23122 }
23123
23124 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23125 {
23126         if (flags & NDR_IN) {
23127         }
23128         if (flags & NDR_OUT) {
23129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23130         }
23131         return NDR_ERR_SUCCESS;
23132 }
23133
23134 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23135 {
23136         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23137         ndr->depth++;
23138         if (flags & NDR_SET_VALUES) {
23139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23140         }
23141         if (flags & NDR_IN) {
23142                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23143                 ndr->depth++;
23144                 ndr->depth--;
23145         }
23146         if (flags & NDR_OUT) {
23147                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23148                 ndr->depth++;
23149                 ndr_print_WERROR(ndr, "result", r->out.result);
23150                 ndr->depth--;
23151         }
23152         ndr->depth--;
23153 }
23154
23155 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23156 {
23157         if (flags & NDR_IN) {
23158         }
23159         if (flags & NDR_OUT) {
23160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23161         }
23162         return NDR_ERR_SUCCESS;
23163 }
23164
23165 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23166 {
23167         if (flags & NDR_IN) {
23168         }
23169         if (flags & NDR_OUT) {
23170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23171         }
23172         return NDR_ERR_SUCCESS;
23173 }
23174
23175 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23176 {
23177         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23178         ndr->depth++;
23179         if (flags & NDR_SET_VALUES) {
23180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23181         }
23182         if (flags & NDR_IN) {
23183                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23184                 ndr->depth++;
23185                 ndr->depth--;
23186         }
23187         if (flags & NDR_OUT) {
23188                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23189                 ndr->depth++;
23190                 ndr_print_WERROR(ndr, "result", r->out.result);
23191                 ndr->depth--;
23192         }
23193         ndr->depth--;
23194 }
23195
23196 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23197 {
23198         if (flags & NDR_IN) {
23199         }
23200         if (flags & NDR_OUT) {
23201                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23202         }
23203         return NDR_ERR_SUCCESS;
23204 }
23205
23206 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23207 {
23208         if (flags & NDR_IN) {
23209         }
23210         if (flags & NDR_OUT) {
23211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23212         }
23213         return NDR_ERR_SUCCESS;
23214 }
23215
23216 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23217 {
23218         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23219         ndr->depth++;
23220         if (flags & NDR_SET_VALUES) {
23221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23222         }
23223         if (flags & NDR_IN) {
23224                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23225                 ndr->depth++;
23226                 ndr->depth--;
23227         }
23228         if (flags & NDR_OUT) {
23229                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23230                 ndr->depth++;
23231                 ndr_print_WERROR(ndr, "result", r->out.result);
23232                 ndr->depth--;
23233         }
23234         ndr->depth--;
23235 }
23236
23237 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23238 {
23239         if (flags & NDR_IN) {
23240         }
23241         if (flags & NDR_OUT) {
23242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23243         }
23244         return NDR_ERR_SUCCESS;
23245 }
23246
23247 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23248 {
23249         if (flags & NDR_IN) {
23250         }
23251         if (flags & NDR_OUT) {
23252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23253         }
23254         return NDR_ERR_SUCCESS;
23255 }
23256
23257 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23258 {
23259         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23260         ndr->depth++;
23261         if (flags & NDR_SET_VALUES) {
23262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23263         }
23264         if (flags & NDR_IN) {
23265                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23266                 ndr->depth++;
23267                 ndr->depth--;
23268         }
23269         if (flags & NDR_OUT) {
23270                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23271                 ndr->depth++;
23272                 ndr_print_WERROR(ndr, "result", r->out.result);
23273                 ndr->depth--;
23274         }
23275         ndr->depth--;
23276 }
23277
23278 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23279 {
23280         if (flags & NDR_IN) {
23281         }
23282         if (flags & NDR_OUT) {
23283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23284         }
23285         return NDR_ERR_SUCCESS;
23286 }
23287
23288 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23289 {
23290         if (flags & NDR_IN) {
23291         }
23292         if (flags & NDR_OUT) {
23293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23294         }
23295         return NDR_ERR_SUCCESS;
23296 }
23297
23298 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23299 {
23300         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23301         ndr->depth++;
23302         if (flags & NDR_SET_VALUES) {
23303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23304         }
23305         if (flags & NDR_IN) {
23306                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23307                 ndr->depth++;
23308                 ndr->depth--;
23309         }
23310         if (flags & NDR_OUT) {
23311                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23312                 ndr->depth++;
23313                 ndr_print_WERROR(ndr, "result", r->out.result);
23314                 ndr->depth--;
23315         }
23316         ndr->depth--;
23317 }
23318
23319 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23320 {
23321         if (flags & NDR_IN) {
23322         }
23323         if (flags & NDR_OUT) {
23324                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23325         }
23326         return NDR_ERR_SUCCESS;
23327 }
23328
23329 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23330 {
23331         if (flags & NDR_IN) {
23332         }
23333         if (flags & NDR_OUT) {
23334                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23335         }
23336         return NDR_ERR_SUCCESS;
23337 }
23338
23339 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23340 {
23341         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23342         ndr->depth++;
23343         if (flags & NDR_SET_VALUES) {
23344                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23345         }
23346         if (flags & NDR_IN) {
23347                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23348                 ndr->depth++;
23349                 ndr->depth--;
23350         }
23351         if (flags & NDR_OUT) {
23352                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23353                 ndr->depth++;
23354                 ndr_print_WERROR(ndr, "result", r->out.result);
23355                 ndr->depth--;
23356         }
23357         ndr->depth--;
23358 }
23359
23360 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23361 {
23362         if (flags & NDR_IN) {
23363         }
23364         if (flags & NDR_OUT) {
23365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23366         }
23367         return NDR_ERR_SUCCESS;
23368 }
23369
23370 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23371 {
23372         if (flags & NDR_IN) {
23373         }
23374         if (flags & NDR_OUT) {
23375                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23376         }
23377         return NDR_ERR_SUCCESS;
23378 }
23379
23380 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23381 {
23382         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23383         ndr->depth++;
23384         if (flags & NDR_SET_VALUES) {
23385                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23386         }
23387         if (flags & NDR_IN) {
23388                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23389                 ndr->depth++;
23390                 ndr->depth--;
23391         }
23392         if (flags & NDR_OUT) {
23393                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23394                 ndr->depth++;
23395                 ndr_print_WERROR(ndr, "result", r->out.result);
23396                 ndr->depth--;
23397         }
23398         ndr->depth--;
23399 }
23400
23401 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23402 {
23403         if (flags & NDR_IN) {
23404         }
23405         if (flags & NDR_OUT) {
23406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23407         }
23408         return NDR_ERR_SUCCESS;
23409 }
23410
23411 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23412 {
23413         if (flags & NDR_IN) {
23414         }
23415         if (flags & NDR_OUT) {
23416                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23417         }
23418         return NDR_ERR_SUCCESS;
23419 }
23420
23421 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23422 {
23423         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23424         ndr->depth++;
23425         if (flags & NDR_SET_VALUES) {
23426                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23427         }
23428         if (flags & NDR_IN) {
23429                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23430                 ndr->depth++;
23431                 ndr->depth--;
23432         }
23433         if (flags & NDR_OUT) {
23434                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23435                 ndr->depth++;
23436                 ndr_print_WERROR(ndr, "result", r->out.result);
23437                 ndr->depth--;
23438         }
23439         ndr->depth--;
23440 }
23441
23442 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23443 {
23444         if (flags & NDR_IN) {
23445         }
23446         if (flags & NDR_OUT) {
23447                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23448         }
23449         return NDR_ERR_SUCCESS;
23450 }
23451
23452 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23453 {
23454         if (flags & NDR_IN) {
23455         }
23456         if (flags & NDR_OUT) {
23457                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23458         }
23459         return NDR_ERR_SUCCESS;
23460 }
23461
23462 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23463 {
23464         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23465         ndr->depth++;
23466         if (flags & NDR_SET_VALUES) {
23467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23468         }
23469         if (flags & NDR_IN) {
23470                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23471                 ndr->depth++;
23472                 ndr->depth--;
23473         }
23474         if (flags & NDR_OUT) {
23475                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23476                 ndr->depth++;
23477                 ndr_print_WERROR(ndr, "result", r->out.result);
23478                 ndr->depth--;
23479         }
23480         ndr->depth--;
23481 }
23482
23483 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23484 {
23485         if (flags & NDR_IN) {
23486         }
23487         if (flags & NDR_OUT) {
23488                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23489         }
23490         return NDR_ERR_SUCCESS;
23491 }
23492
23493 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23494 {
23495         if (flags & NDR_IN) {
23496         }
23497         if (flags & NDR_OUT) {
23498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23499         }
23500         return NDR_ERR_SUCCESS;
23501 }
23502
23503 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23504 {
23505         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23506         ndr->depth++;
23507         if (flags & NDR_SET_VALUES) {
23508                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23509         }
23510         if (flags & NDR_IN) {
23511                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23512                 ndr->depth++;
23513                 ndr->depth--;
23514         }
23515         if (flags & NDR_OUT) {
23516                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23517                 ndr->depth++;
23518                 ndr_print_WERROR(ndr, "result", r->out.result);
23519                 ndr->depth--;
23520         }
23521         ndr->depth--;
23522 }
23523
23524 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23525 {
23526         if (flags & NDR_IN) {
23527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23528                 if (r->in.servername) {
23529                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23532                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23533                 }
23534                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23535                 if (r->in.print_processor_name) {
23536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23539                         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));
23540                 }
23541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23542                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23543                 if (r->in.buffer) {
23544                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23545                 }
23546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23547         }
23548         if (flags & NDR_OUT) {
23549                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23550                 if (r->out.info) {
23551                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23552                 }
23553                 if (r->out.needed == NULL) {
23554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23555                 }
23556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23557                 if (r->out.count == NULL) {
23558                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23559                 }
23560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23561                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23562         }
23563         return NDR_ERR_SUCCESS;
23564 }
23565
23566 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23567 {
23568         uint32_t _ptr_servername;
23569         uint32_t _ptr_print_processor_name;
23570         uint32_t _ptr_buffer;
23571         uint32_t _ptr_info;
23572         TALLOC_CTX *_mem_save_servername_0;
23573         TALLOC_CTX *_mem_save_print_processor_name_0;
23574         TALLOC_CTX *_mem_save_buffer_0;
23575         TALLOC_CTX *_mem_save_info_0;
23576         TALLOC_CTX *_mem_save_needed_0;
23577         TALLOC_CTX *_mem_save_count_0;
23578         if (flags & NDR_IN) {
23579                 ZERO_STRUCT(r->out);
23580
23581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23582                 if (_ptr_servername) {
23583                         NDR_PULL_ALLOC(ndr, r->in.servername);
23584                 } else {
23585                         r->in.servername = NULL;
23586                 }
23587                 if (r->in.servername) {
23588                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23589                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23590                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23591                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23592                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23593                                 return 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));
23594                         }
23595                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23596                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23597                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23598                 }
23599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23600                 if (_ptr_print_processor_name) {
23601                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23602                 } else {
23603                         r->in.print_processor_name = NULL;
23604                 }
23605                 if (r->in.print_processor_name) {
23606                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23607                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23610                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23611                                 return 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));
23612                         }
23613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23614                         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));
23615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23616                 }
23617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23619                 if (_ptr_buffer) {
23620                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23621                 } else {
23622                         r->in.buffer = NULL;
23623                 }
23624                 if (r->in.buffer) {
23625                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23626                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23627                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23628                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23629                 }
23630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23631                 NDR_PULL_ALLOC(ndr, r->out.needed);
23632                 ZERO_STRUCTP(r->out.needed);
23633                 NDR_PULL_ALLOC(ndr, r->out.count);
23634                 ZERO_STRUCTP(r->out.count);
23635         }
23636         if (flags & NDR_OUT) {
23637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23638                 if (_ptr_info) {
23639                         NDR_PULL_ALLOC(ndr, r->out.info);
23640                 } else {
23641                         r->out.info = NULL;
23642                 }
23643                 if (r->out.info) {
23644                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23645                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23646                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23648                 }
23649                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23650                         NDR_PULL_ALLOC(ndr, r->out.needed);
23651                 }
23652                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23653                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23655                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23657                         NDR_PULL_ALLOC(ndr, r->out.count);
23658                 }
23659                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23660                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23664         }
23665         return NDR_ERR_SUCCESS;
23666 }
23667
23668 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23669 {
23670         uint32_t cntr_info_0;
23671         if (flags & NDR_IN) {
23672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23674         }
23675         if (flags & NDR_OUT) {
23676                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23677                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23678                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23679                 }
23680                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23681                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23682                 }
23683         }
23684         return NDR_ERR_SUCCESS;
23685 }
23686
23687 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23688 {
23689         uint32_t cntr_info_0;
23690         TALLOC_CTX *_mem_save_info_0;
23691         if (flags & NDR_IN) {
23692                 ZERO_STRUCT(r->out);
23693
23694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23696         }
23697         if (flags & NDR_OUT) {
23698                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23699                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23701                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23702                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23703                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23704                 }
23705                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23706                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23707                 }
23708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23709         }
23710         return NDR_ERR_SUCCESS;
23711 }
23712
23713 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23714 {
23715         uint32_t cntr_info_2;
23716         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23717         ndr->depth++;
23718         if (flags & NDR_SET_VALUES) {
23719                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23720         }
23721         if (flags & NDR_IN) {
23722                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23723                 ndr->depth++;
23724                 ndr_print_ptr(ndr, "servername", r->in.servername);
23725                 ndr->depth++;
23726                 if (r->in.servername) {
23727                         ndr_print_string(ndr, "servername", r->in.servername);
23728                 }
23729                 ndr->depth--;
23730                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23731                 ndr->depth++;
23732                 if (r->in.print_processor_name) {
23733                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23734                 }
23735                 ndr->depth--;
23736                 ndr_print_uint32(ndr, "level", r->in.level);
23737                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23738                 ndr->depth++;
23739                 if (r->in.buffer) {
23740                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23741                 }
23742                 ndr->depth--;
23743                 ndr_print_uint32(ndr, "offered", r->in.offered);
23744                 ndr->depth--;
23745         }
23746         if (flags & NDR_OUT) {
23747                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23748                 ndr->depth++;
23749                 ndr_print_ptr(ndr, "count", r->out.count);
23750                 ndr->depth++;
23751                 ndr_print_uint32(ndr, "count", *r->out.count);
23752                 ndr->depth--;
23753                 ndr_print_ptr(ndr, "info", r->out.info);
23754                 ndr->depth++;
23755                 ndr_print_ptr(ndr, "info", *r->out.info);
23756                 ndr->depth++;
23757                 if (*r->out.info) {
23758                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23759                         ndr->depth++;
23760                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23761                                 char *idx_2=NULL;
23762                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23763                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23764                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23765                                         free(idx_2);
23766                                 }
23767                         }
23768                         ndr->depth--;
23769                 }
23770                 ndr->depth--;
23771                 ndr->depth--;
23772                 ndr_print_ptr(ndr, "needed", r->out.needed);
23773                 ndr->depth++;
23774                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23775                 ndr->depth--;
23776                 ndr_print_WERROR(ndr, "result", r->out.result);
23777                 ndr->depth--;
23778         }
23779         ndr->depth--;
23780 }
23781
23782 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23783 {
23784         if (flags & NDR_IN) {
23785                 if (r->in.handle == NULL) {
23786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23787                 }
23788                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23790                 if (r->in.data_type) {
23791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23794                         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));
23795                 }
23796                 if (r->in.devmode_ctr == NULL) {
23797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23798                 }
23799                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23800         }
23801         if (flags & NDR_OUT) {
23802                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23803         }
23804         return NDR_ERR_SUCCESS;
23805 }
23806
23807 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23808 {
23809         uint32_t _ptr_data_type;
23810         TALLOC_CTX *_mem_save_handle_0;
23811         TALLOC_CTX *_mem_save_data_type_0;
23812         TALLOC_CTX *_mem_save_devmode_ctr_0;
23813         if (flags & NDR_IN) {
23814                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23815                         NDR_PULL_ALLOC(ndr, r->in.handle);
23816                 }
23817                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23818                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23819                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23820                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23822                 if (_ptr_data_type) {
23823                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23824                 } else {
23825                         r->in.data_type = NULL;
23826                 }
23827                 if (r->in.data_type) {
23828                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23829                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23832                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23833                                 return 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));
23834                         }
23835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23836                         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));
23837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23838                 }
23839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23840                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23841                 }
23842                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23844                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23846         }
23847         if (flags & NDR_OUT) {
23848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23849         }
23850         return NDR_ERR_SUCCESS;
23851 }
23852
23853 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23854 {
23855         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23856         ndr->depth++;
23857         if (flags & NDR_SET_VALUES) {
23858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23859         }
23860         if (flags & NDR_IN) {
23861                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23862                 ndr->depth++;
23863                 ndr_print_ptr(ndr, "handle", r->in.handle);
23864                 ndr->depth++;
23865                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23866                 ndr->depth--;
23867                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23868                 ndr->depth++;
23869                 if (r->in.data_type) {
23870                         ndr_print_string(ndr, "data_type", r->in.data_type);
23871                 }
23872                 ndr->depth--;
23873                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23874                 ndr->depth++;
23875                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23876                 ndr->depth--;
23877                 ndr->depth--;
23878         }
23879         if (flags & NDR_OUT) {
23880                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23881                 ndr->depth++;
23882                 ndr_print_WERROR(ndr, "result", r->out.result);
23883                 ndr->depth--;
23884         }
23885         ndr->depth--;
23886 }
23887
23888 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23889 {
23890         if (flags & NDR_IN) {
23891                 if (r->in.handle == NULL) {
23892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23893                 }
23894                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23896                 if (r->in.architecture) {
23897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23901                 }
23902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23904                 if (r->in.buffer) {
23905                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23906                 }
23907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23910         }
23911         if (flags & NDR_OUT) {
23912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23913                 if (r->out.info) {
23914                         {
23915                                 struct ndr_push *_ndr_info;
23916                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23917                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23918                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23919                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23920                         }
23921                 }
23922                 if (r->out.needed == NULL) {
23923                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23924                 }
23925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23926                 if (r->out.server_major_version == NULL) {
23927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23928                 }
23929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
23930                 if (r->out.server_minor_version == NULL) {
23931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23932                 }
23933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
23934                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23935         }
23936         return NDR_ERR_SUCCESS;
23937 }
23938
23939 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
23940 {
23941         uint32_t _ptr_architecture;
23942         uint32_t _ptr_buffer;
23943         uint32_t _ptr_info;
23944         TALLOC_CTX *_mem_save_handle_0;
23945         TALLOC_CTX *_mem_save_architecture_0;
23946         TALLOC_CTX *_mem_save_buffer_0;
23947         TALLOC_CTX *_mem_save_info_0;
23948         TALLOC_CTX *_mem_save_needed_0;
23949         TALLOC_CTX *_mem_save_server_major_version_0;
23950         TALLOC_CTX *_mem_save_server_minor_version_0;
23951         if (flags & NDR_IN) {
23952                 ZERO_STRUCT(r->out);
23953
23954                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23955                         NDR_PULL_ALLOC(ndr, r->in.handle);
23956                 }
23957                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23958                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23959                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23960                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
23962                 if (_ptr_architecture) {
23963                         NDR_PULL_ALLOC(ndr, r->in.architecture);
23964                 } else {
23965                         r->in.architecture = NULL;
23966                 }
23967                 if (r->in.architecture) {
23968                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
23969                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
23970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
23971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
23972                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
23973                                 return 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));
23974                         }
23975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
23976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
23977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
23978                 }
23979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23981                 if (_ptr_buffer) {
23982                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23983                 } else {
23984                         r->in.buffer = NULL;
23985                 }
23986                 if (r->in.buffer) {
23987                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23988                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23989                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23991                 }
23992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
23994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
23995                 NDR_PULL_ALLOC(ndr, r->out.needed);
23996                 ZERO_STRUCTP(r->out.needed);
23997                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
23998                 ZERO_STRUCTP(r->out.server_major_version);
23999                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24000                 ZERO_STRUCTP(r->out.server_minor_version);
24001         }
24002         if (flags & NDR_OUT) {
24003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24004                 if (_ptr_info) {
24005                         NDR_PULL_ALLOC(ndr, r->out.info);
24006                 } else {
24007                         r->out.info = NULL;
24008                 }
24009                 if (r->out.info) {
24010                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24011                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24012                         {
24013                                 struct ndr_pull *_ndr_info;
24014                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24015                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24016                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24017                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24018                         }
24019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24020                 }
24021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24022                         NDR_PULL_ALLOC(ndr, r->out.needed);
24023                 }
24024                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24025                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24029                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24030                 }
24031                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24035                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24036                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24037                 }
24038                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24039                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24041                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24042                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24043         }
24044         return NDR_ERR_SUCCESS;
24045 }
24046
24047 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24048 {
24049         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24050         ndr->depth++;
24051         if (flags & NDR_SET_VALUES) {
24052                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24053         }
24054         if (flags & NDR_IN) {
24055                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24056                 ndr->depth++;
24057                 ndr_print_ptr(ndr, "handle", r->in.handle);
24058                 ndr->depth++;
24059                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24060                 ndr->depth--;
24061                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24062                 ndr->depth++;
24063                 if (r->in.architecture) {
24064                         ndr_print_string(ndr, "architecture", r->in.architecture);
24065                 }
24066                 ndr->depth--;
24067                 ndr_print_uint32(ndr, "level", r->in.level);
24068                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24069                 ndr->depth++;
24070                 if (r->in.buffer) {
24071                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24072                 }
24073                 ndr->depth--;
24074                 ndr_print_uint32(ndr, "offered", r->in.offered);
24075                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24076                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24077                 ndr->depth--;
24078         }
24079         if (flags & NDR_OUT) {
24080                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24081                 ndr->depth++;
24082                 ndr_print_ptr(ndr, "info", r->out.info);
24083                 ndr->depth++;
24084                 if (r->out.info) {
24085                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24086                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24087                 }
24088                 ndr->depth--;
24089                 ndr_print_ptr(ndr, "needed", r->out.needed);
24090                 ndr->depth++;
24091                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24092                 ndr->depth--;
24093                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24094                 ndr->depth++;
24095                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24096                 ndr->depth--;
24097                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24098                 ndr->depth++;
24099                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24100                 ndr->depth--;
24101                 ndr_print_WERROR(ndr, "result", r->out.result);
24102                 ndr->depth--;
24103         }
24104         ndr->depth--;
24105 }
24106
24107 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24108 {
24109         if (flags & NDR_IN) {
24110         }
24111         if (flags & NDR_OUT) {
24112                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24113         }
24114         return NDR_ERR_SUCCESS;
24115 }
24116
24117 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24118 {
24119         if (flags & NDR_IN) {
24120         }
24121         if (flags & NDR_OUT) {
24122                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24123         }
24124         return NDR_ERR_SUCCESS;
24125 }
24126
24127 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24128 {
24129         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24130         ndr->depth++;
24131         if (flags & NDR_SET_VALUES) {
24132                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24133         }
24134         if (flags & NDR_IN) {
24135                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24136                 ndr->depth++;
24137                 ndr->depth--;
24138         }
24139         if (flags & NDR_OUT) {
24140                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24141                 ndr->depth++;
24142                 ndr_print_WERROR(ndr, "result", r->out.result);
24143                 ndr->depth--;
24144         }
24145         ndr->depth--;
24146 }
24147
24148 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24149 {
24150         if (flags & NDR_IN) {
24151         }
24152         if (flags & NDR_OUT) {
24153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24154         }
24155         return NDR_ERR_SUCCESS;
24156 }
24157
24158 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24159 {
24160         if (flags & NDR_IN) {
24161         }
24162         if (flags & NDR_OUT) {
24163                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24164         }
24165         return NDR_ERR_SUCCESS;
24166 }
24167
24168 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24169 {
24170         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24171         ndr->depth++;
24172         if (flags & NDR_SET_VALUES) {
24173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24174         }
24175         if (flags & NDR_IN) {
24176                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24177                 ndr->depth++;
24178                 ndr->depth--;
24179         }
24180         if (flags & NDR_OUT) {
24181                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24182                 ndr->depth++;
24183                 ndr_print_WERROR(ndr, "result", r->out.result);
24184                 ndr->depth--;
24185         }
24186         ndr->depth--;
24187 }
24188
24189 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24190 {
24191         if (flags & NDR_IN) {
24192                 if (r->in.handle == NULL) {
24193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24194                 }
24195                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24196         }
24197         if (flags & NDR_OUT) {
24198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24199         }
24200         return NDR_ERR_SUCCESS;
24201 }
24202
24203 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24204 {
24205         TALLOC_CTX *_mem_save_handle_0;
24206         if (flags & NDR_IN) {
24207                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24208                         NDR_PULL_ALLOC(ndr, r->in.handle);
24209                 }
24210                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24211                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24212                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24214         }
24215         if (flags & NDR_OUT) {
24216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24217         }
24218         return NDR_ERR_SUCCESS;
24219 }
24220
24221 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24222 {
24223         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24224         ndr->depth++;
24225         if (flags & NDR_SET_VALUES) {
24226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24227         }
24228         if (flags & NDR_IN) {
24229                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24230                 ndr->depth++;
24231                 ndr_print_ptr(ndr, "handle", r->in.handle);
24232                 ndr->depth++;
24233                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24234                 ndr->depth--;
24235                 ndr->depth--;
24236         }
24237         if (flags & NDR_OUT) {
24238                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24239                 ndr->depth++;
24240                 ndr_print_WERROR(ndr, "result", r->out.result);
24241                 ndr->depth--;
24242         }
24243         ndr->depth--;
24244 }
24245
24246 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24247 {
24248         if (flags & NDR_IN) {
24249         }
24250         if (flags & NDR_OUT) {
24251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24252         }
24253         return NDR_ERR_SUCCESS;
24254 }
24255
24256 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24257 {
24258         if (flags & NDR_IN) {
24259         }
24260         if (flags & NDR_OUT) {
24261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24262         }
24263         return NDR_ERR_SUCCESS;
24264 }
24265
24266 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24267 {
24268         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24269         ndr->depth++;
24270         if (flags & NDR_SET_VALUES) {
24271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24272         }
24273         if (flags & NDR_IN) {
24274                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24275                 ndr->depth++;
24276                 ndr->depth--;
24277         }
24278         if (flags & NDR_OUT) {
24279                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24280                 ndr->depth++;
24281                 ndr_print_WERROR(ndr, "result", r->out.result);
24282                 ndr->depth--;
24283         }
24284         ndr->depth--;
24285 }
24286
24287 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24288 {
24289         if (flags & NDR_IN) {
24290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24293                 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));
24294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24295                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24298                 if (r->in.buffer) {
24299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24300                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24301                 }
24302         }
24303         if (flags & NDR_OUT) {
24304                 if (r->out.handle == NULL) {
24305                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24306                 }
24307                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24308                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24309         }
24310         return NDR_ERR_SUCCESS;
24311 }
24312
24313 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24314 {
24315         uint32_t _ptr_buffer;
24316         TALLOC_CTX *_mem_save_buffer_0;
24317         TALLOC_CTX *_mem_save_handle_0;
24318         if (flags & NDR_IN) {
24319                 ZERO_STRUCT(r->out);
24320
24321                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24322                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24323                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24324                         return 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));
24325                 }
24326                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24327                 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));
24328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24329                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24331                 if (r->in.bufsize > 512) {
24332                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24333                 }
24334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24335                 if (_ptr_buffer) {
24336                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24337                 } else {
24338                         r->in.buffer = NULL;
24339                 }
24340                 if (r->in.buffer) {
24341                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24342                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24344                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24345                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24347                 }
24348                 NDR_PULL_ALLOC(ndr, r->out.handle);
24349                 ZERO_STRUCTP(r->out.handle);
24350                 if (r->in.buffer) {
24351                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24352                 }
24353         }
24354         if (flags & NDR_OUT) {
24355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24356                         NDR_PULL_ALLOC(ndr, r->out.handle);
24357                 }
24358                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24359                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24360                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24362                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24363         }
24364         return NDR_ERR_SUCCESS;
24365 }
24366
24367 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24368 {
24369         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24370         ndr->depth++;
24371         if (flags & NDR_SET_VALUES) {
24372                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24373         }
24374         if (flags & NDR_IN) {
24375                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24376                 ndr->depth++;
24377                 ndr_print_string(ndr, "server_name", r->in.server_name);
24378                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24379                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24380                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24381                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24382                 ndr->depth++;
24383                 if (r->in.buffer) {
24384                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24385                 }
24386                 ndr->depth--;
24387                 ndr->depth--;
24388         }
24389         if (flags & NDR_OUT) {
24390                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24391                 ndr->depth++;
24392                 ndr_print_ptr(ndr, "handle", r->out.handle);
24393                 ndr->depth++;
24394                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24395                 ndr->depth--;
24396                 ndr_print_WERROR(ndr, "result", r->out.result);
24397                 ndr->depth--;
24398         }
24399         ndr->depth--;
24400 }
24401
24402 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24403 {
24404         if (flags & NDR_IN) {
24405                 if (r->in.handle == NULL) {
24406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24407                 }
24408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24409                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24412                 if (r->in.buffer) {
24413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24414                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24415                 }
24416         }
24417         if (flags & NDR_OUT) {
24418                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24419         }
24420         return NDR_ERR_SUCCESS;
24421 }
24422
24423 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24424 {
24425         uint32_t _ptr_buffer;
24426         TALLOC_CTX *_mem_save_handle_0;
24427         TALLOC_CTX *_mem_save_buffer_0;
24428         if (flags & NDR_IN) {
24429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24430                         NDR_PULL_ALLOC(ndr, r->in.handle);
24431                 }
24432                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24433                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24434                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24436                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24438                 if (r->in.bufsize > 512) {
24439                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24440                 }
24441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24442                 if (_ptr_buffer) {
24443                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24444                 } else {
24445                         r->in.buffer = NULL;
24446                 }
24447                 if (r->in.buffer) {
24448                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24449                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24450                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24451                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24452                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24454                 }
24455                 if (r->in.buffer) {
24456                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24457                 }
24458         }
24459         if (flags & NDR_OUT) {
24460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24461         }
24462         return NDR_ERR_SUCCESS;
24463 }
24464
24465 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24466 {
24467         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24468         ndr->depth++;
24469         if (flags & NDR_SET_VALUES) {
24470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24471         }
24472         if (flags & NDR_IN) {
24473                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24474                 ndr->depth++;
24475                 ndr_print_ptr(ndr, "handle", r->in.handle);
24476                 ndr->depth++;
24477                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24478                 ndr->depth--;
24479                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24480                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24481                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24482                 ndr->depth++;
24483                 if (r->in.buffer) {
24484                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24485                 }
24486                 ndr->depth--;
24487                 ndr->depth--;
24488         }
24489         if (flags & NDR_OUT) {
24490                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24491                 ndr->depth++;
24492                 ndr_print_WERROR(ndr, "result", r->out.result);
24493                 ndr->depth--;
24494         }
24495         ndr->depth--;
24496 }
24497
24498 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24499 {
24500         if (flags & NDR_IN) {
24501                 if (r->in.handle == NULL) {
24502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24503                 }
24504                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24505         }
24506         if (flags & NDR_OUT) {
24507                 if (r->out.handle == NULL) {
24508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24509                 }
24510                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24512         }
24513         return NDR_ERR_SUCCESS;
24514 }
24515
24516 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24517 {
24518         TALLOC_CTX *_mem_save_handle_0;
24519         if (flags & NDR_IN) {
24520                 ZERO_STRUCT(r->out);
24521
24522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24523                         NDR_PULL_ALLOC(ndr, r->in.handle);
24524                 }
24525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24529                 NDR_PULL_ALLOC(ndr, r->out.handle);
24530                 *r->out.handle = *r->in.handle;
24531         }
24532         if (flags & NDR_OUT) {
24533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24534                         NDR_PULL_ALLOC(ndr, r->out.handle);
24535                 }
24536                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24538                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24541         }
24542         return NDR_ERR_SUCCESS;
24543 }
24544
24545 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24546 {
24547         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24548         ndr->depth++;
24549         if (flags & NDR_SET_VALUES) {
24550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24551         }
24552         if (flags & NDR_IN) {
24553                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24554                 ndr->depth++;
24555                 ndr_print_ptr(ndr, "handle", r->in.handle);
24556                 ndr->depth++;
24557                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24558                 ndr->depth--;
24559                 ndr->depth--;
24560         }
24561         if (flags & NDR_OUT) {
24562                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24563                 ndr->depth++;
24564                 ndr_print_ptr(ndr, "handle", r->out.handle);
24565                 ndr->depth++;
24566                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24567                 ndr->depth--;
24568                 ndr_print_WERROR(ndr, "result", r->out.result);
24569                 ndr->depth--;
24570         }
24571         ndr->depth--;
24572 }
24573
24574 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24575 {
24576         if (flags & NDR_IN) {
24577         }
24578         if (flags & NDR_OUT) {
24579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24580         }
24581         return NDR_ERR_SUCCESS;
24582 }
24583
24584 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24585 {
24586         if (flags & NDR_IN) {
24587         }
24588         if (flags & NDR_OUT) {
24589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24590         }
24591         return NDR_ERR_SUCCESS;
24592 }
24593
24594 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24595 {
24596         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24597         ndr->depth++;
24598         if (flags & NDR_SET_VALUES) {
24599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24600         }
24601         if (flags & NDR_IN) {
24602                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24603                 ndr->depth++;
24604                 ndr->depth--;
24605         }
24606         if (flags & NDR_OUT) {
24607                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24608                 ndr->depth++;
24609                 ndr_print_WERROR(ndr, "result", r->out.result);
24610                 ndr->depth--;
24611         }
24612         ndr->depth--;
24613 }
24614
24615 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24616 {
24617         if (flags & NDR_IN) {
24618         }
24619         if (flags & NDR_OUT) {
24620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24621         }
24622         return NDR_ERR_SUCCESS;
24623 }
24624
24625 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24626 {
24627         if (flags & NDR_IN) {
24628         }
24629         if (flags & NDR_OUT) {
24630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24631         }
24632         return NDR_ERR_SUCCESS;
24633 }
24634
24635 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24636 {
24637         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24638         ndr->depth++;
24639         if (flags & NDR_SET_VALUES) {
24640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24641         }
24642         if (flags & NDR_IN) {
24643                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24644                 ndr->depth++;
24645                 ndr->depth--;
24646         }
24647         if (flags & NDR_OUT) {
24648                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24649                 ndr->depth++;
24650                 ndr_print_WERROR(ndr, "result", r->out.result);
24651                 ndr->depth--;
24652         }
24653         ndr->depth--;
24654 }
24655
24656 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24657 {
24658         if (flags & NDR_IN) {
24659         }
24660         if (flags & NDR_OUT) {
24661                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24662         }
24663         return NDR_ERR_SUCCESS;
24664 }
24665
24666 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24667 {
24668         if (flags & NDR_IN) {
24669         }
24670         if (flags & NDR_OUT) {
24671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24672         }
24673         return NDR_ERR_SUCCESS;
24674 }
24675
24676 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24677 {
24678         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24679         ndr->depth++;
24680         if (flags & NDR_SET_VALUES) {
24681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24682         }
24683         if (flags & NDR_IN) {
24684                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24685                 ndr->depth++;
24686                 ndr->depth--;
24687         }
24688         if (flags & NDR_OUT) {
24689                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24690                 ndr->depth++;
24691                 ndr_print_WERROR(ndr, "result", r->out.result);
24692                 ndr->depth--;
24693         }
24694         ndr->depth--;
24695 }
24696
24697 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24698 {
24699         if (flags & NDR_IN) {
24700         }
24701         if (flags & NDR_OUT) {
24702                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24703         }
24704         return NDR_ERR_SUCCESS;
24705 }
24706
24707 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24708 {
24709         if (flags & NDR_IN) {
24710         }
24711         if (flags & NDR_OUT) {
24712                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24713         }
24714         return NDR_ERR_SUCCESS;
24715 }
24716
24717 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24718 {
24719         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24720         ndr->depth++;
24721         if (flags & NDR_SET_VALUES) {
24722                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24723         }
24724         if (flags & NDR_IN) {
24725                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24726                 ndr->depth++;
24727                 ndr->depth--;
24728         }
24729         if (flags & NDR_OUT) {
24730                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24731                 ndr->depth++;
24732                 ndr_print_WERROR(ndr, "result", r->out.result);
24733                 ndr->depth--;
24734         }
24735         ndr->depth--;
24736 }
24737
24738 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24739 {
24740         if (flags & NDR_IN) {
24741                 if (r->in.handle == NULL) {
24742                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24743                 }
24744                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24745                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24748                 if (r->in.local_machine) {
24749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24750                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24752                         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));
24753                 }
24754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24756                 if (r->in.notify_options) {
24757                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24758                 }
24759         }
24760         if (flags & NDR_OUT) {
24761                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24762         }
24763         return NDR_ERR_SUCCESS;
24764 }
24765
24766 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24767 {
24768         uint32_t _ptr_local_machine;
24769         uint32_t _ptr_notify_options;
24770         TALLOC_CTX *_mem_save_handle_0;
24771         TALLOC_CTX *_mem_save_local_machine_0;
24772         TALLOC_CTX *_mem_save_notify_options_0;
24773         if (flags & NDR_IN) {
24774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24775                         NDR_PULL_ALLOC(ndr, r->in.handle);
24776                 }
24777                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24781                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24784                 if (_ptr_local_machine) {
24785                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24786                 } else {
24787                         r->in.local_machine = NULL;
24788                 }
24789                 if (r->in.local_machine) {
24790                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24794                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24795                                 return 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));
24796                         }
24797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24798                         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));
24799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24800                 }
24801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24803                 if (_ptr_notify_options) {
24804                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24805                 } else {
24806                         r->in.notify_options = NULL;
24807                 }
24808                 if (r->in.notify_options) {
24809                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24811                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24813                 }
24814         }
24815         if (flags & NDR_OUT) {
24816                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24817         }
24818         return NDR_ERR_SUCCESS;
24819 }
24820
24821 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24822 {
24823         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24824         ndr->depth++;
24825         if (flags & NDR_SET_VALUES) {
24826                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24827         }
24828         if (flags & NDR_IN) {
24829                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24830                 ndr->depth++;
24831                 ndr_print_ptr(ndr, "handle", r->in.handle);
24832                 ndr->depth++;
24833                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24834                 ndr->depth--;
24835                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24836                 ndr_print_uint32(ndr, "options", r->in.options);
24837                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24838                 ndr->depth++;
24839                 if (r->in.local_machine) {
24840                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24841                 }
24842                 ndr->depth--;
24843                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24844                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24845                 ndr->depth++;
24846                 if (r->in.notify_options) {
24847                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24848                 }
24849                 ndr->depth--;
24850                 ndr->depth--;
24851         }
24852         if (flags & NDR_OUT) {
24853                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24854                 ndr->depth++;
24855                 ndr_print_WERROR(ndr, "result", r->out.result);
24856                 ndr->depth--;
24857         }
24858         ndr->depth--;
24859 }
24860
24861 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24862 {
24863         if (flags & NDR_IN) {
24864                 if (r->in.handle == NULL) {
24865                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24866                 }
24867                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24869                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24871                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24872                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24873         }
24874         if (flags & NDR_OUT) {
24875                 if (r->out.reply_result == NULL) {
24876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24877                 }
24878                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24879                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24880         }
24881         return NDR_ERR_SUCCESS;
24882 }
24883
24884 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24885 {
24886         TALLOC_CTX *_mem_save_handle_0;
24887         TALLOC_CTX *_mem_save_reply_result_0;
24888         if (flags & NDR_IN) {
24889                 ZERO_STRUCT(r->out);
24890
24891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24892                         NDR_PULL_ALLOC(ndr, r->in.handle);
24893                 }
24894                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24895                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24896                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24899                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24901                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24902                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24903                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24904                 ZERO_STRUCTP(r->out.reply_result);
24905         }
24906         if (flags & NDR_OUT) {
24907                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24908                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24909                 }
24910                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24911                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24912                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24913                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24915         }
24916         return NDR_ERR_SUCCESS;
24917 }
24918
24919 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24920 {
24921         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24922         ndr->depth++;
24923         if (flags & NDR_SET_VALUES) {
24924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24925         }
24926         if (flags & NDR_IN) {
24927                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
24928                 ndr->depth++;
24929                 ndr_print_ptr(ndr, "handle", r->in.handle);
24930                 ndr->depth++;
24931                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24932                 ndr->depth--;
24933                 ndr_print_uint32(ndr, "color", r->in.color);
24934                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24935                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
24936                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
24937                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
24938                 ndr->depth--;
24939         }
24940         if (flags & NDR_OUT) {
24941                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
24942                 ndr->depth++;
24943                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
24944                 ndr->depth++;
24945                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
24946                 ndr->depth--;
24947                 ndr_print_WERROR(ndr, "result", r->out.result);
24948                 ndr->depth--;
24949         }
24950         ndr->depth--;
24951 }
24952
24953 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
24954 {
24955         if (flags & NDR_IN) {
24956                 if (r->in.handle == NULL) {
24957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24958                 }
24959                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
24961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
24962                 if (r->in.options) {
24963                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24964                 }
24965         }
24966         if (flags & NDR_OUT) {
24967                 if (r->out.info == NULL) {
24968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24969                 }
24970                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
24971                 if (*r->out.info) {
24972                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
24973                 }
24974                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24975         }
24976         return NDR_ERR_SUCCESS;
24977 }
24978
24979 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
24980 {
24981         uint32_t _ptr_options;
24982         uint32_t _ptr_info;
24983         TALLOC_CTX *_mem_save_handle_0;
24984         TALLOC_CTX *_mem_save_options_0;
24985         TALLOC_CTX *_mem_save_info_0;
24986         TALLOC_CTX *_mem_save_info_1;
24987         if (flags & NDR_IN) {
24988                 ZERO_STRUCT(r->out);
24989
24990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24991                         NDR_PULL_ALLOC(ndr, r->in.handle);
24992                 }
24993                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24994                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24995                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
24998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
24999                 if (_ptr_options) {
25000                         NDR_PULL_ALLOC(ndr, r->in.options);
25001                 } else {
25002                         r->in.options = NULL;
25003                 }
25004                 if (r->in.options) {
25005                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25006                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25007                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25009                 }
25010                 NDR_PULL_ALLOC(ndr, r->out.info);
25011                 ZERO_STRUCTP(r->out.info);
25012         }
25013         if (flags & NDR_OUT) {
25014                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25015                         NDR_PULL_ALLOC(ndr, r->out.info);
25016                 }
25017                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25018                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25020                 if (_ptr_info) {
25021                         NDR_PULL_ALLOC(ndr, *r->out.info);
25022                 } else {
25023                         *r->out.info = NULL;
25024                 }
25025                 if (*r->out.info) {
25026                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25027                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25028                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25030                 }
25031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25033         }
25034         return NDR_ERR_SUCCESS;
25035 }
25036
25037 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25038 {
25039         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25040         ndr->depth++;
25041         if (flags & NDR_SET_VALUES) {
25042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25043         }
25044         if (flags & NDR_IN) {
25045                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25046                 ndr->depth++;
25047                 ndr_print_ptr(ndr, "handle", r->in.handle);
25048                 ndr->depth++;
25049                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25050                 ndr->depth--;
25051                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25052                 ndr_print_ptr(ndr, "options", r->in.options);
25053                 ndr->depth++;
25054                 if (r->in.options) {
25055                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25056                 }
25057                 ndr->depth--;
25058                 ndr->depth--;
25059         }
25060         if (flags & NDR_OUT) {
25061                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25062                 ndr->depth++;
25063                 ndr_print_ptr(ndr, "info", r->out.info);
25064                 ndr->depth++;
25065                 ndr_print_ptr(ndr, "info", *r->out.info);
25066                 ndr->depth++;
25067                 if (*r->out.info) {
25068                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25069                 }
25070                 ndr->depth--;
25071                 ndr->depth--;
25072                 ndr_print_WERROR(ndr, "result", r->out.result);
25073                 ndr->depth--;
25074         }
25075         ndr->depth--;
25076 }
25077
25078 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25079 {
25080         if (flags & NDR_IN) {
25081         }
25082         if (flags & NDR_OUT) {
25083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25084         }
25085         return NDR_ERR_SUCCESS;
25086 }
25087
25088 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25089 {
25090         if (flags & NDR_IN) {
25091         }
25092         if (flags & NDR_OUT) {
25093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25094         }
25095         return NDR_ERR_SUCCESS;
25096 }
25097
25098 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25099 {
25100         ndr_print_struct(ndr, name, "spoolss_44");
25101         ndr->depth++;
25102         if (flags & NDR_SET_VALUES) {
25103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25104         }
25105         if (flags & NDR_IN) {
25106                 ndr_print_struct(ndr, "in", "spoolss_44");
25107                 ndr->depth++;
25108                 ndr->depth--;
25109         }
25110         if (flags & NDR_OUT) {
25111                 ndr_print_struct(ndr, "out", "spoolss_44");
25112                 ndr->depth++;
25113                 ndr_print_WERROR(ndr, "result", r->out.result);
25114                 ndr->depth--;
25115         }
25116         ndr->depth--;
25117 }
25118
25119 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25120 {
25121         if (flags & NDR_IN) {
25122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25123                 if (r->in.printername) {
25124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25127                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25128                 }
25129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25130                 if (r->in.datatype) {
25131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25132                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25135                 }
25136                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25137                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25139                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25140                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25141         }
25142         if (flags & NDR_OUT) {
25143                 if (r->out.handle == NULL) {
25144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25145                 }
25146                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25147                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25148         }
25149         return NDR_ERR_SUCCESS;
25150 }
25151
25152 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25153 {
25154         uint32_t _ptr_printername;
25155         uint32_t _ptr_datatype;
25156         TALLOC_CTX *_mem_save_printername_0;
25157         TALLOC_CTX *_mem_save_datatype_0;
25158         TALLOC_CTX *_mem_save_handle_0;
25159         if (flags & NDR_IN) {
25160                 ZERO_STRUCT(r->out);
25161
25162                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25163                 if (_ptr_printername) {
25164                         NDR_PULL_ALLOC(ndr, r->in.printername);
25165                 } else {
25166                         r->in.printername = NULL;
25167                 }
25168                 if (r->in.printername) {
25169                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25170                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25172                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25173                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25174                                 return 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));
25175                         }
25176                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25179                 }
25180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25181                 if (_ptr_datatype) {
25182                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25183                 } else {
25184                         r->in.datatype = NULL;
25185                 }
25186                 if (r->in.datatype) {
25187                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25188                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25189                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25190                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25191                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25192                                 return 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));
25193                         }
25194                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25195                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25197                 }
25198                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25199                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25201                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25202                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25203                 NDR_PULL_ALLOC(ndr, r->out.handle);
25204                 ZERO_STRUCTP(r->out.handle);
25205         }
25206         if (flags & NDR_OUT) {
25207                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25208                         NDR_PULL_ALLOC(ndr, r->out.handle);
25209                 }
25210                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25211                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25212                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25214                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25215         }
25216         return NDR_ERR_SUCCESS;
25217 }
25218
25219 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25220 {
25221         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25222         ndr->depth++;
25223         if (flags & NDR_SET_VALUES) {
25224                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25225         }
25226         if (flags & NDR_IN) {
25227                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25228                 ndr->depth++;
25229                 ndr_print_ptr(ndr, "printername", r->in.printername);
25230                 ndr->depth++;
25231                 if (r->in.printername) {
25232                         ndr_print_string(ndr, "printername", r->in.printername);
25233                 }
25234                 ndr->depth--;
25235                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25236                 ndr->depth++;
25237                 if (r->in.datatype) {
25238                         ndr_print_string(ndr, "datatype", r->in.datatype);
25239                 }
25240                 ndr->depth--;
25241                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25242                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25243                 ndr_print_uint32(ndr, "level", r->in.level);
25244                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25245                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25246                 ndr->depth--;
25247         }
25248         if (flags & NDR_OUT) {
25249                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25250                 ndr->depth++;
25251                 ndr_print_ptr(ndr, "handle", r->out.handle);
25252                 ndr->depth++;
25253                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25254                 ndr->depth--;
25255                 ndr_print_WERROR(ndr, "result", r->out.result);
25256                 ndr->depth--;
25257         }
25258         ndr->depth--;
25259 }
25260
25261 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25262 {
25263         if (flags & NDR_IN) {
25264                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25265                 if (r->in.server) {
25266                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25269                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25270                 }
25271                 if (r->in.info_ctr == NULL) {
25272                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25273                 }
25274                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25275                 if (r->in.devmode_ctr == NULL) {
25276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25277                 }
25278                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25279                 if (r->in.secdesc_ctr == NULL) {
25280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25281                 }
25282                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25283                 if (r->in.userlevel_ctr == NULL) {
25284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25285                 }
25286                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25287         }
25288         if (flags & NDR_OUT) {
25289                 if (r->out.handle == NULL) {
25290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25291                 }
25292                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25293                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25294         }
25295         return NDR_ERR_SUCCESS;
25296 }
25297
25298 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25299 {
25300         uint32_t _ptr_server;
25301         TALLOC_CTX *_mem_save_server_0;
25302         TALLOC_CTX *_mem_save_info_ctr_0;
25303         TALLOC_CTX *_mem_save_devmode_ctr_0;
25304         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25305         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25306         TALLOC_CTX *_mem_save_handle_0;
25307         if (flags & NDR_IN) {
25308                 ZERO_STRUCT(r->out);
25309
25310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25311                 if (_ptr_server) {
25312                         NDR_PULL_ALLOC(ndr, r->in.server);
25313                 } else {
25314                         r->in.server = NULL;
25315                 }
25316                 if (r->in.server) {
25317                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25318                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25320                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25321                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25322                                 return 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));
25323                         }
25324                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25325                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25327                 }
25328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25329                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25330                 }
25331                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25333                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25336                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25337                 }
25338                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25339                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25340                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25343                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25344                 }
25345                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25346                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25347                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25350                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25351                 }
25352                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25353                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25354                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25356                 NDR_PULL_ALLOC(ndr, r->out.handle);
25357                 ZERO_STRUCTP(r->out.handle);
25358         }
25359         if (flags & NDR_OUT) {
25360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25361                         NDR_PULL_ALLOC(ndr, r->out.handle);
25362                 }
25363                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25364                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25367                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25368         }
25369         return NDR_ERR_SUCCESS;
25370 }
25371
25372 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25373 {
25374         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25375         ndr->depth++;
25376         if (flags & NDR_SET_VALUES) {
25377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25378         }
25379         if (flags & NDR_IN) {
25380                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25381                 ndr->depth++;
25382                 ndr_print_ptr(ndr, "server", r->in.server);
25383                 ndr->depth++;
25384                 if (r->in.server) {
25385                         ndr_print_string(ndr, "server", r->in.server);
25386                 }
25387                 ndr->depth--;
25388                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25389                 ndr->depth++;
25390                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25391                 ndr->depth--;
25392                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25393                 ndr->depth++;
25394                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25395                 ndr->depth--;
25396                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25397                 ndr->depth++;
25398                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25399                 ndr->depth--;
25400                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25401                 ndr->depth++;
25402                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25403                 ndr->depth--;
25404                 ndr->depth--;
25405         }
25406         if (flags & NDR_OUT) {
25407                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25408                 ndr->depth++;
25409                 ndr_print_ptr(ndr, "handle", r->out.handle);
25410                 ndr->depth++;
25411                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25412                 ndr->depth--;
25413                 ndr_print_WERROR(ndr, "result", r->out.result);
25414                 ndr->depth--;
25415         }
25416         ndr->depth--;
25417 }
25418
25419 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25420 {
25421         if (flags & NDR_IN) {
25422         }
25423         if (flags & NDR_OUT) {
25424                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25425         }
25426         return NDR_ERR_SUCCESS;
25427 }
25428
25429 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25430 {
25431         if (flags & NDR_IN) {
25432         }
25433         if (flags & NDR_OUT) {
25434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25435         }
25436         return NDR_ERR_SUCCESS;
25437 }
25438
25439 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25440 {
25441         ndr_print_struct(ndr, name, "spoolss_47");
25442         ndr->depth++;
25443         if (flags & NDR_SET_VALUES) {
25444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25445         }
25446         if (flags & NDR_IN) {
25447                 ndr_print_struct(ndr, "in", "spoolss_47");
25448                 ndr->depth++;
25449                 ndr->depth--;
25450         }
25451         if (flags & NDR_OUT) {
25452                 ndr_print_struct(ndr, "out", "spoolss_47");
25453                 ndr->depth++;
25454                 ndr_print_WERROR(ndr, "result", r->out.result);
25455                 ndr->depth--;
25456         }
25457         ndr->depth--;
25458 }
25459
25460 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25461 {
25462         if (flags & NDR_IN) {
25463                 if (r->in.handle == NULL) {
25464                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25465                 }
25466                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25470         }
25471         if (flags & NDR_OUT) {
25472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25473                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25474                 if (r->out.value_needed == NULL) {
25475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25476                 }
25477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25478                 if (r->out.printerdata_type == NULL) {
25479                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25480                 }
25481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
25482                 if (r->out.buffer == NULL) {
25483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25484                 }
25485                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
25486                 if (r->out.data_needed == NULL) {
25487                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25488                 }
25489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25491         }
25492         return NDR_ERR_SUCCESS;
25493 }
25494
25495 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25496 {
25497         TALLOC_CTX *_mem_save_handle_0;
25498         TALLOC_CTX *_mem_save_value_needed_0;
25499         TALLOC_CTX *_mem_save_printerdata_type_0;
25500         TALLOC_CTX *_mem_save_buffer_0;
25501         TALLOC_CTX *_mem_save_data_needed_0;
25502         if (flags & NDR_IN) {
25503                 ZERO_STRUCT(r->out);
25504
25505                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25506                         NDR_PULL_ALLOC(ndr, r->in.handle);
25507                 }
25508                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25509                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25510                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25511                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25515                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25516                 ZERO_STRUCTP(r->out.value_needed);
25517                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25518                 ZERO_STRUCTP(r->out.printerdata_type);
25519                 NDR_PULL_ALLOC(ndr, r->out.buffer);
25520                 ZERO_STRUCTP(r->out.buffer);
25521                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25522                 ZERO_STRUCTP(r->out.data_needed);
25523         }
25524         if (flags & NDR_OUT) {
25525                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25526                 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));
25527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25528                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25529                 }
25530                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25531                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25534                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25535                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25536                 }
25537                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25538                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
25539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
25540                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
25541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25542                         NDR_PULL_ALLOC(ndr, r->out.buffer);
25543                 }
25544                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
25546                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
25547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
25548                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25549                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25550                 }
25551                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25552                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25554                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25556                 if (r->out.value_name) {
25557                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25558                 }
25559         }
25560         return NDR_ERR_SUCCESS;
25561 }
25562
25563 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25564 {
25565         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25566         ndr->depth++;
25567         if (flags & NDR_SET_VALUES) {
25568                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25569         }
25570         if (flags & NDR_IN) {
25571                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25572                 ndr->depth++;
25573                 ndr_print_ptr(ndr, "handle", r->in.handle);
25574                 ndr->depth++;
25575                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25576                 ndr->depth--;
25577                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25578                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25579                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25580                 ndr->depth--;
25581         }
25582         if (flags & NDR_OUT) {
25583                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25584                 ndr->depth++;
25585                 ndr_print_string(ndr, "value_name", r->out.value_name);
25586                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25587                 ndr->depth++;
25588                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25589                 ndr->depth--;
25590                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
25591                 ndr->depth++;
25592                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
25593                 ndr->depth--;
25594                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25595                 ndr->depth++;
25596                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
25597                 ndr->depth--;
25598                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25599                 ndr->depth++;
25600                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25601                 ndr->depth--;
25602                 ndr_print_WERROR(ndr, "result", r->out.result);
25603                 ndr->depth--;
25604         }
25605         ndr->depth--;
25606 }
25607
25608 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25609 {
25610         if (flags & NDR_IN) {
25611                 if (r->in.handle == NULL) {
25612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25613                 }
25614                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25618                 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));
25619         }
25620         if (flags & NDR_OUT) {
25621                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25622         }
25623         return NDR_ERR_SUCCESS;
25624 }
25625
25626 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25627 {
25628         TALLOC_CTX *_mem_save_handle_0;
25629         if (flags & NDR_IN) {
25630                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25631                         NDR_PULL_ALLOC(ndr, r->in.handle);
25632                 }
25633                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25634                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25635                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25636                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25637                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25638                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25639                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25640                         return 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));
25641                 }
25642                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25643                 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));
25644         }
25645         if (flags & NDR_OUT) {
25646                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25647         }
25648         return NDR_ERR_SUCCESS;
25649 }
25650
25651 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25652 {
25653         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
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_DeletePrinterData");
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_string(ndr, "value_name", r->in.value_name);
25666                 ndr->depth--;
25667         }
25668         if (flags & NDR_OUT) {
25669                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25670                 ndr->depth++;
25671                 ndr_print_WERROR(ndr, "result", r->out.result);
25672                 ndr->depth--;
25673         }
25674         ndr->depth--;
25675 }
25676
25677 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25678 {
25679         if (flags & NDR_IN) {
25680         }
25681         if (flags & NDR_OUT) {
25682                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25683         }
25684         return NDR_ERR_SUCCESS;
25685 }
25686
25687 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25688 {
25689         if (flags & NDR_IN) {
25690         }
25691         if (flags & NDR_OUT) {
25692                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25693         }
25694         return NDR_ERR_SUCCESS;
25695 }
25696
25697 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25698 {
25699         ndr_print_struct(ndr, name, "spoolss_4a");
25700         ndr->depth++;
25701         if (flags & NDR_SET_VALUES) {
25702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25703         }
25704         if (flags & NDR_IN) {
25705                 ndr_print_struct(ndr, "in", "spoolss_4a");
25706                 ndr->depth++;
25707                 ndr->depth--;
25708         }
25709         if (flags & NDR_OUT) {
25710                 ndr_print_struct(ndr, "out", "spoolss_4a");
25711                 ndr->depth++;
25712                 ndr_print_WERROR(ndr, "result", r->out.result);
25713                 ndr->depth--;
25714         }
25715         ndr->depth--;
25716 }
25717
25718 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25719 {
25720         if (flags & NDR_IN) {
25721         }
25722         if (flags & NDR_OUT) {
25723                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25724         }
25725         return NDR_ERR_SUCCESS;
25726 }
25727
25728 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25729 {
25730         if (flags & NDR_IN) {
25731         }
25732         if (flags & NDR_OUT) {
25733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25734         }
25735         return NDR_ERR_SUCCESS;
25736 }
25737
25738 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25739 {
25740         ndr_print_struct(ndr, name, "spoolss_4b");
25741         ndr->depth++;
25742         if (flags & NDR_SET_VALUES) {
25743                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25744         }
25745         if (flags & NDR_IN) {
25746                 ndr_print_struct(ndr, "in", "spoolss_4b");
25747                 ndr->depth++;
25748                 ndr->depth--;
25749         }
25750         if (flags & NDR_OUT) {
25751                 ndr_print_struct(ndr, "out", "spoolss_4b");
25752                 ndr->depth++;
25753                 ndr_print_WERROR(ndr, "result", r->out.result);
25754                 ndr->depth--;
25755         }
25756         ndr->depth--;
25757 }
25758
25759 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25760 {
25761         if (flags & NDR_IN) {
25762         }
25763         if (flags & NDR_OUT) {
25764                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25765         }
25766         return NDR_ERR_SUCCESS;
25767 }
25768
25769 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25770 {
25771         if (flags & NDR_IN) {
25772         }
25773         if (flags & NDR_OUT) {
25774                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25775         }
25776         return NDR_ERR_SUCCESS;
25777 }
25778
25779 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25780 {
25781         ndr_print_struct(ndr, name, "spoolss_4c");
25782         ndr->depth++;
25783         if (flags & NDR_SET_VALUES) {
25784                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25785         }
25786         if (flags & NDR_IN) {
25787                 ndr_print_struct(ndr, "in", "spoolss_4c");
25788                 ndr->depth++;
25789                 ndr->depth--;
25790         }
25791         if (flags & NDR_OUT) {
25792                 ndr_print_struct(ndr, "out", "spoolss_4c");
25793                 ndr->depth++;
25794                 ndr_print_WERROR(ndr, "result", r->out.result);
25795                 ndr->depth--;
25796         }
25797         ndr->depth--;
25798 }
25799
25800 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25801 {
25802         if (flags & NDR_IN) {
25803                 if (r->in.handle == NULL) {
25804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25805                 }
25806                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25810                 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));
25811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25814                 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));
25815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
25816                 if (r->in.buffer == NULL) {
25817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25818                 }
25819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25820                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25822         }
25823         if (flags & NDR_OUT) {
25824                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25825         }
25826         return NDR_ERR_SUCCESS;
25827 }
25828
25829 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25830 {
25831         TALLOC_CTX *_mem_save_handle_0;
25832         if (flags & NDR_IN) {
25833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25834                         NDR_PULL_ALLOC(ndr, r->in.handle);
25835                 }
25836                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25837                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25838                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25840                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25841                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25842                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25843                         return 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));
25844                 }
25845                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25846                 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));
25847                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25848                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25849                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25850                         return 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));
25851                 }
25852                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25853                 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));
25854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
25855                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25857                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25858                 }
25859                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25861                 if (r->in.buffer) {
25862                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25863                 }
25864         }
25865         if (flags & NDR_OUT) {
25866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25867         }
25868         return NDR_ERR_SUCCESS;
25869 }
25870
25871 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25872 {
25873         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25874         ndr->depth++;
25875         if (flags & NDR_SET_VALUES) {
25876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25877         }
25878         if (flags & NDR_IN) {
25879                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25880                 ndr->depth++;
25881                 ndr_print_ptr(ndr, "handle", r->in.handle);
25882                 ndr->depth++;
25883                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25884                 ndr->depth--;
25885                 ndr_print_string(ndr, "key_name", r->in.key_name);
25886                 ndr_print_string(ndr, "value_name", r->in.value_name);
25887                 ndr_print_uint32(ndr, "type", r->in.type);
25888                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25889                 ndr->depth++;
25890                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25891                 ndr->depth--;
25892                 ndr_print_uint32(ndr, "offered", r->in.offered);
25893                 ndr->depth--;
25894         }
25895         if (flags & NDR_OUT) {
25896                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25897                 ndr->depth++;
25898                 ndr_print_WERROR(ndr, "result", r->out.result);
25899                 ndr->depth--;
25900         }
25901         ndr->depth--;
25902 }
25903
25904 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25905 {
25906         if (flags & NDR_IN) {
25907                 if (r->in.handle == NULL) {
25908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25909                 }
25910                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25914                 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));
25915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25918                 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));
25919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25920         }
25921         if (flags & NDR_OUT) {
25922                 if (r->out.type == NULL) {
25923                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25924                 }
25925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
25926                 if (r->out.buffer == NULL) {
25927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25928                 }
25929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25930                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
25931                 if (r->out.needed == NULL) {
25932                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25933                 }
25934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25935                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25936         }
25937         return NDR_ERR_SUCCESS;
25938 }
25939
25940 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
25941 {
25942         TALLOC_CTX *_mem_save_handle_0;
25943         TALLOC_CTX *_mem_save_type_0;
25944         TALLOC_CTX *_mem_save_needed_0;
25945         if (flags & NDR_IN) {
25946                 ZERO_STRUCT(r->out);
25947
25948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25949                         NDR_PULL_ALLOC(ndr, r->in.handle);
25950                 }
25951                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25952                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25953                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25955                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25956                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25957                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25958                         return 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));
25959                 }
25960                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25961                 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));
25962                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25963                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25964                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25965                         return 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));
25966                 }
25967                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25968                 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));
25969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25970                 NDR_PULL_ALLOC(ndr, r->out.type);
25971                 ZERO_STRUCTP(r->out.type);
25972                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
25973                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
25974                 NDR_PULL_ALLOC(ndr, r->out.needed);
25975                 ZERO_STRUCTP(r->out.needed);
25976         }
25977         if (flags & NDR_OUT) {
25978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25979                         NDR_PULL_ALLOC(ndr, r->out.type);
25980                 }
25981                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25982                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
25984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25985                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
25986                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25987                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
25988                 }
25989                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
25990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25991                         NDR_PULL_ALLOC(ndr, r->out.needed);
25992                 }
25993                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25997                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25998                 if (r->out.buffer) {
25999                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26000                 }
26001         }
26002         return NDR_ERR_SUCCESS;
26003 }
26004
26005 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26006 {
26007         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26008         ndr->depth++;
26009         if (flags & NDR_SET_VALUES) {
26010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26011         }
26012         if (flags & NDR_IN) {
26013                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26014                 ndr->depth++;
26015                 ndr_print_ptr(ndr, "handle", r->in.handle);
26016                 ndr->depth++;
26017                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26018                 ndr->depth--;
26019                 ndr_print_string(ndr, "key_name", r->in.key_name);
26020                 ndr_print_string(ndr, "value_name", r->in.value_name);
26021                 ndr_print_uint32(ndr, "offered", r->in.offered);
26022                 ndr->depth--;
26023         }
26024         if (flags & NDR_OUT) {
26025                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26026                 ndr->depth++;
26027                 ndr_print_ptr(ndr, "type", r->out.type);
26028                 ndr->depth++;
26029                 ndr_print_uint32(ndr, "type", *r->out.type);
26030                 ndr->depth--;
26031                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26032                 ndr->depth++;
26033                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26034                 ndr->depth--;
26035                 ndr_print_ptr(ndr, "needed", r->out.needed);
26036                 ndr->depth++;
26037                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26038                 ndr->depth--;
26039                 ndr_print_WERROR(ndr, "result", r->out.result);
26040                 ndr->depth--;
26041         }
26042         ndr->depth--;
26043 }
26044
26045 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26046 {
26047         if (flags & NDR_IN) {
26048                 if (r->in.handle == NULL) {
26049                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26050                 }
26051                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26055                 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));
26056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26057         }
26058         if (flags & NDR_OUT) {
26059                 if (r->out.buffer == NULL) {
26060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26061                 }
26062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26063                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26064                 if (r->out.needed == NULL) {
26065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26066                 }
26067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26068                 if (r->out.count == NULL) {
26069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26070                 }
26071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26072                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26073         }
26074         return NDR_ERR_SUCCESS;
26075 }
26076
26077 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26078 {
26079         TALLOC_CTX *_mem_save_handle_0;
26080         TALLOC_CTX *_mem_save_needed_0;
26081         TALLOC_CTX *_mem_save_count_0;
26082         if (flags & NDR_IN) {
26083                 ZERO_STRUCT(r->out);
26084
26085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26086                         NDR_PULL_ALLOC(ndr, r->in.handle);
26087                 }
26088                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26089                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26090                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26092                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26093                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26094                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26095                         return 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));
26096                 }
26097                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26098                 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));
26099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26100                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26101                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26102                 NDR_PULL_ALLOC(ndr, r->out.needed);
26103                 ZERO_STRUCTP(r->out.needed);
26104                 NDR_PULL_ALLOC(ndr, r->out.count);
26105                 ZERO_STRUCTP(r->out.count);
26106         }
26107         if (flags & NDR_OUT) {
26108                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26109                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26110                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26111                 }
26112                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26114                         NDR_PULL_ALLOC(ndr, r->out.needed);
26115                 }
26116                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26117                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26121                         NDR_PULL_ALLOC(ndr, r->out.count);
26122                 }
26123                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26124                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26127                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26128                 if (r->out.buffer) {
26129                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26130                 }
26131         }
26132         return NDR_ERR_SUCCESS;
26133 }
26134
26135 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26136 {
26137         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26138         ndr->depth++;
26139         if (flags & NDR_SET_VALUES) {
26140                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26141         }
26142         if (flags & NDR_IN) {
26143                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26144                 ndr->depth++;
26145                 ndr_print_ptr(ndr, "handle", r->in.handle);
26146                 ndr->depth++;
26147                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26148                 ndr->depth--;
26149                 ndr_print_string(ndr, "key_name", r->in.key_name);
26150                 ndr_print_uint32(ndr, "offered", r->in.offered);
26151                 ndr->depth--;
26152         }
26153         if (flags & NDR_OUT) {
26154                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26155                 ndr->depth++;
26156                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26157                 ndr->depth++;
26158                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26159                 ndr->depth--;
26160                 ndr_print_ptr(ndr, "needed", r->out.needed);
26161                 ndr->depth++;
26162                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26163                 ndr->depth--;
26164                 ndr_print_ptr(ndr, "count", r->out.count);
26165                 ndr->depth++;
26166                 ndr_print_uint32(ndr, "count", *r->out.count);
26167                 ndr->depth--;
26168                 ndr_print_WERROR(ndr, "result", r->out.result);
26169                 ndr->depth--;
26170         }
26171         ndr->depth--;
26172 }
26173
26174 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26175 {
26176         uint32_t cntr_key_buffer_1;
26177         if (flags & NDR_IN) {
26178                 if (r->in.handle == NULL) {
26179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26180                 }
26181                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26185                 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));
26186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
26187         }
26188         if (flags & NDR_OUT) {
26189                 if (r->out.key_buffer == NULL) {
26190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26191                 }
26192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
26193                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26194                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
26195                 }
26196                 if (r->out.needed == NULL) {
26197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26198                 }
26199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26200                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26201         }
26202         return NDR_ERR_SUCCESS;
26203 }
26204
26205 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26206 {
26207         uint32_t cntr_key_buffer_1;
26208         TALLOC_CTX *_mem_save_handle_0;
26209         TALLOC_CTX *_mem_save_key_buffer_1;
26210         TALLOC_CTX *_mem_save_needed_0;
26211         if (flags & NDR_IN) {
26212                 ZERO_STRUCT(r->out);
26213
26214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26215                         NDR_PULL_ALLOC(ndr, r->in.handle);
26216                 }
26217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26221                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26222                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26223                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26224                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
26225                 }
26226                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26227                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
26228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
26229                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
26230                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
26231                 NDR_PULL_ALLOC(ndr, r->out.needed);
26232                 ZERO_STRUCTP(r->out.needed);
26233         }
26234         if (flags & NDR_OUT) {
26235                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
26236                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26237                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
26238                 }
26239                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26240                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
26241                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26242                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
26243                 }
26244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26246                         NDR_PULL_ALLOC(ndr, r->out.needed);
26247                 }
26248                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26249                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26253                 if (r->out.key_buffer) {
26254                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
26255                 }
26256         }
26257         return NDR_ERR_SUCCESS;
26258 }
26259
26260 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26261 {
26262         uint32_t cntr_key_buffer_1;
26263         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26264         ndr->depth++;
26265         if (flags & NDR_SET_VALUES) {
26266                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26267         }
26268         if (flags & NDR_IN) {
26269                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26270                 ndr->depth++;
26271                 ndr_print_ptr(ndr, "handle", r->in.handle);
26272                 ndr->depth++;
26273                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26274                 ndr->depth--;
26275                 ndr_print_string(ndr, "key_name", r->in.key_name);
26276                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
26277                 ndr->depth--;
26278         }
26279         if (flags & NDR_OUT) {
26280                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26281                 ndr->depth++;
26282                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26283                 ndr->depth++;
26284                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
26285                 ndr->depth++;
26286                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
26287                         char *idx_1=NULL;
26288                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
26289                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
26290                                 free(idx_1);
26291                         }
26292                 }
26293                 ndr->depth--;
26294                 ndr->depth--;
26295                 ndr_print_ptr(ndr, "needed", r->out.needed);
26296                 ndr->depth++;
26297                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26298                 ndr->depth--;
26299                 ndr_print_WERROR(ndr, "result", r->out.result);
26300                 ndr->depth--;
26301         }
26302         ndr->depth--;
26303 }
26304
26305 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26306 {
26307         if (flags & NDR_IN) {
26308                 if (r->in.handle == NULL) {
26309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26310                 }
26311                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26315                 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));
26316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26319                 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));
26320         }
26321         if (flags & NDR_OUT) {
26322                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26323         }
26324         return NDR_ERR_SUCCESS;
26325 }
26326
26327 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26328 {
26329         TALLOC_CTX *_mem_save_handle_0;
26330         if (flags & NDR_IN) {
26331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26332                         NDR_PULL_ALLOC(ndr, r->in.handle);
26333                 }
26334                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26335                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26336                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26337                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26338                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26339                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26340                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26341                         return 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));
26342                 }
26343                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26344                 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));
26345                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26346                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26347                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26348                         return 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));
26349                 }
26350                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26351                 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));
26352         }
26353         if (flags & NDR_OUT) {
26354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26355         }
26356         return NDR_ERR_SUCCESS;
26357 }
26358
26359 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26360 {
26361         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26362         ndr->depth++;
26363         if (flags & NDR_SET_VALUES) {
26364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26365         }
26366         if (flags & NDR_IN) {
26367                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26368                 ndr->depth++;
26369                 ndr_print_ptr(ndr, "handle", r->in.handle);
26370                 ndr->depth++;
26371                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26372                 ndr->depth--;
26373                 ndr_print_string(ndr, "key_name", r->in.key_name);
26374                 ndr_print_string(ndr, "value_name", r->in.value_name);
26375                 ndr->depth--;
26376         }
26377         if (flags & NDR_OUT) {
26378                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26379                 ndr->depth++;
26380                 ndr_print_WERROR(ndr, "result", r->out.result);
26381                 ndr->depth--;
26382         }
26383         ndr->depth--;
26384 }
26385
26386 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26387 {
26388         if (flags & NDR_IN) {
26389                 if (r->in.handle == NULL) {
26390                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26391                 }
26392                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26396                 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));
26397         }
26398         if (flags & NDR_OUT) {
26399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26400         }
26401         return NDR_ERR_SUCCESS;
26402 }
26403
26404 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26405 {
26406         TALLOC_CTX *_mem_save_handle_0;
26407         if (flags & NDR_IN) {
26408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26409                         NDR_PULL_ALLOC(ndr, r->in.handle);
26410                 }
26411                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26412                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26413                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26415                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26416                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26417                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26418                         return 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));
26419                 }
26420                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26421                 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));
26422         }
26423         if (flags & NDR_OUT) {
26424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26425         }
26426         return NDR_ERR_SUCCESS;
26427 }
26428
26429 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26430 {
26431         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26432         ndr->depth++;
26433         if (flags & NDR_SET_VALUES) {
26434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26435         }
26436         if (flags & NDR_IN) {
26437                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26438                 ndr->depth++;
26439                 ndr_print_ptr(ndr, "handle", r->in.handle);
26440                 ndr->depth++;
26441                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26442                 ndr->depth--;
26443                 ndr_print_string(ndr, "key_name", r->in.key_name);
26444                 ndr->depth--;
26445         }
26446         if (flags & NDR_OUT) {
26447                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26448                 ndr->depth++;
26449                 ndr_print_WERROR(ndr, "result", r->out.result);
26450                 ndr->depth--;
26451         }
26452         ndr->depth--;
26453 }
26454
26455 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26456 {
26457         if (flags & NDR_IN) {
26458         }
26459         if (flags & NDR_OUT) {
26460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26461         }
26462         return NDR_ERR_SUCCESS;
26463 }
26464
26465 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26466 {
26467         if (flags & NDR_IN) {
26468         }
26469         if (flags & NDR_OUT) {
26470                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26471         }
26472         return NDR_ERR_SUCCESS;
26473 }
26474
26475 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26476 {
26477         ndr_print_struct(ndr, name, "spoolss_53");
26478         ndr->depth++;
26479         if (flags & NDR_SET_VALUES) {
26480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26481         }
26482         if (flags & NDR_IN) {
26483                 ndr_print_struct(ndr, "in", "spoolss_53");
26484                 ndr->depth++;
26485                 ndr->depth--;
26486         }
26487         if (flags & NDR_OUT) {
26488                 ndr_print_struct(ndr, "out", "spoolss_53");
26489                 ndr->depth++;
26490                 ndr_print_WERROR(ndr, "result", r->out.result);
26491                 ndr->depth--;
26492         }
26493         ndr->depth--;
26494 }
26495
26496 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26497 {
26498         if (flags & NDR_IN) {
26499                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26500                 if (r->in.server) {
26501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
26504                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26505                 }
26506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26509                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26513                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26514                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26516         }
26517         if (flags & NDR_OUT) {
26518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26519         }
26520         return NDR_ERR_SUCCESS;
26521 }
26522
26523 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26524 {
26525         uint32_t _ptr_server;
26526         TALLOC_CTX *_mem_save_server_0;
26527         if (flags & NDR_IN) {
26528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26529                 if (_ptr_server) {
26530                         NDR_PULL_ALLOC(ndr, r->in.server);
26531                 } else {
26532                         r->in.server = NULL;
26533                 }
26534                 if (r->in.server) {
26535                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26536                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26539                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26540                                 return 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));
26541                         }
26542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26545                 }
26546                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26547                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26548                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26549                         return 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));
26550                 }
26551                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26552                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26553                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26554                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26555                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26556                         return 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));
26557                 }
26558                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26559                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26560                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26562         }
26563         if (flags & NDR_OUT) {
26564                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26565         }
26566         return NDR_ERR_SUCCESS;
26567 }
26568
26569 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26570 {
26571         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26572         ndr->depth++;
26573         if (flags & NDR_SET_VALUES) {
26574                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26575         }
26576         if (flags & NDR_IN) {
26577                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26578                 ndr->depth++;
26579                 ndr_print_ptr(ndr, "server", r->in.server);
26580                 ndr->depth++;
26581                 if (r->in.server) {
26582                         ndr_print_string(ndr, "server", r->in.server);
26583                 }
26584                 ndr->depth--;
26585                 ndr_print_string(ndr, "architecture", r->in.architecture);
26586                 ndr_print_string(ndr, "driver", r->in.driver);
26587                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26588                 ndr_print_uint32(ndr, "version", r->in.version);
26589                 ndr->depth--;
26590         }
26591         if (flags & NDR_OUT) {
26592                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26593                 ndr->depth++;
26594                 ndr_print_WERROR(ndr, "result", r->out.result);
26595                 ndr->depth--;
26596         }
26597         ndr->depth--;
26598 }
26599
26600 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26601 {
26602         if (flags & NDR_IN) {
26603         }
26604         if (flags & NDR_OUT) {
26605                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26606         }
26607         return NDR_ERR_SUCCESS;
26608 }
26609
26610 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26611 {
26612         if (flags & NDR_IN) {
26613         }
26614         if (flags & NDR_OUT) {
26615                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26616         }
26617         return NDR_ERR_SUCCESS;
26618 }
26619
26620 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26621 {
26622         ndr_print_struct(ndr, name, "spoolss_55");
26623         ndr->depth++;
26624         if (flags & NDR_SET_VALUES) {
26625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26626         }
26627         if (flags & NDR_IN) {
26628                 ndr_print_struct(ndr, "in", "spoolss_55");
26629                 ndr->depth++;
26630                 ndr->depth--;
26631         }
26632         if (flags & NDR_OUT) {
26633                 ndr_print_struct(ndr, "out", "spoolss_55");
26634                 ndr->depth++;
26635                 ndr_print_WERROR(ndr, "result", r->out.result);
26636                 ndr->depth--;
26637         }
26638         ndr->depth--;
26639 }
26640
26641 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26642 {
26643         if (flags & NDR_IN) {
26644         }
26645         if (flags & NDR_OUT) {
26646                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26647         }
26648         return NDR_ERR_SUCCESS;
26649 }
26650
26651 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26652 {
26653         if (flags & NDR_IN) {
26654         }
26655         if (flags & NDR_OUT) {
26656                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26657         }
26658         return NDR_ERR_SUCCESS;
26659 }
26660
26661 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26662 {
26663         ndr_print_struct(ndr, name, "spoolss_56");
26664         ndr->depth++;
26665         if (flags & NDR_SET_VALUES) {
26666                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26667         }
26668         if (flags & NDR_IN) {
26669                 ndr_print_struct(ndr, "in", "spoolss_56");
26670                 ndr->depth++;
26671                 ndr->depth--;
26672         }
26673         if (flags & NDR_OUT) {
26674                 ndr_print_struct(ndr, "out", "spoolss_56");
26675                 ndr->depth++;
26676                 ndr_print_WERROR(ndr, "result", r->out.result);
26677                 ndr->depth--;
26678         }
26679         ndr->depth--;
26680 }
26681
26682 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26683 {
26684         if (flags & NDR_IN) {
26685         }
26686         if (flags & NDR_OUT) {
26687                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26688         }
26689         return NDR_ERR_SUCCESS;
26690 }
26691
26692 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26693 {
26694         if (flags & NDR_IN) {
26695         }
26696         if (flags & NDR_OUT) {
26697                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26698         }
26699         return NDR_ERR_SUCCESS;
26700 }
26701
26702 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26703 {
26704         ndr_print_struct(ndr, name, "spoolss_57");
26705         ndr->depth++;
26706         if (flags & NDR_SET_VALUES) {
26707                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26708         }
26709         if (flags & NDR_IN) {
26710                 ndr_print_struct(ndr, "in", "spoolss_57");
26711                 ndr->depth++;
26712                 ndr->depth--;
26713         }
26714         if (flags & NDR_OUT) {
26715                 ndr_print_struct(ndr, "out", "spoolss_57");
26716                 ndr->depth++;
26717                 ndr_print_WERROR(ndr, "result", r->out.result);
26718                 ndr->depth--;
26719         }
26720         ndr->depth--;
26721 }
26722
26723 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26724 {
26725         if (flags & NDR_IN) {
26726                 if (r->in.handle == NULL) {
26727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26728                 }
26729                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26733                 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));
26734                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26737                 if (r->in.status_code == NULL) {
26738                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26739                 }
26740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26741         }
26742         if (flags & NDR_OUT) {
26743                 if (r->out.out_data == NULL) {
26744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26745                 }
26746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26747                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26748                 if (r->out.needed == NULL) {
26749                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26750                 }
26751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26752                 if (r->out.status_code == NULL) {
26753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26754                 }
26755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26756                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26757         }
26758         return NDR_ERR_SUCCESS;
26759 }
26760
26761 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26762 {
26763         TALLOC_CTX *_mem_save_handle_0;
26764         TALLOC_CTX *_mem_save_needed_0;
26765         TALLOC_CTX *_mem_save_status_code_0;
26766         if (flags & NDR_IN) {
26767                 ZERO_STRUCT(r->out);
26768
26769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26770                         NDR_PULL_ALLOC(ndr, r->in.handle);
26771                 }
26772                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26773                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26774                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26776                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26777                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26778                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26779                         return 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));
26780                 }
26781                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26782                 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));
26783                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26787                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26788                 }
26789                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26793                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26794                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26795                 NDR_PULL_ALLOC(ndr, r->out.needed);
26796                 ZERO_STRUCTP(r->out.needed);
26797                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26798                 *r->out.status_code = *r->in.status_code;
26799         }
26800         if (flags & NDR_OUT) {
26801                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26803                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26804                 }
26805                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26807                         NDR_PULL_ALLOC(ndr, r->out.needed);
26808                 }
26809                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26810                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26813                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26814                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26815                 }
26816                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26817                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26820                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26821                 if (r->out.out_data) {
26822                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26823                 }
26824         }
26825         return NDR_ERR_SUCCESS;
26826 }
26827
26828 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26829 {
26830         ndr_print_struct(ndr, name, "spoolss_XcvData");
26831         ndr->depth++;
26832         if (flags & NDR_SET_VALUES) {
26833                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26834         }
26835         if (flags & NDR_IN) {
26836                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26837                 ndr->depth++;
26838                 ndr_print_ptr(ndr, "handle", r->in.handle);
26839                 ndr->depth++;
26840                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26841                 ndr->depth--;
26842                 ndr_print_string(ndr, "function_name", r->in.function_name);
26843                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26844                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26845                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26846                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26847                 ndr->depth++;
26848                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26849                 ndr->depth--;
26850                 ndr->depth--;
26851         }
26852         if (flags & NDR_OUT) {
26853                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26854                 ndr->depth++;
26855                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26856                 ndr->depth++;
26857                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26858                 ndr->depth--;
26859                 ndr_print_ptr(ndr, "needed", r->out.needed);
26860                 ndr->depth++;
26861                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26862                 ndr->depth--;
26863                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26864                 ndr->depth++;
26865                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26866                 ndr->depth--;
26867                 ndr_print_WERROR(ndr, "result", r->out.result);
26868                 ndr->depth--;
26869         }
26870         ndr->depth--;
26871 }
26872
26873 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26874 {
26875         if (flags & NDR_IN) {
26876                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26877                 if (r->in.servername) {
26878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26881                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26882                 }
26883                 if (r->in.info_ctr == NULL) {
26884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26885                 }
26886                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26887                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26888         }
26889         if (flags & NDR_OUT) {
26890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26891         }
26892         return NDR_ERR_SUCCESS;
26893 }
26894
26895 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
26896 {
26897         uint32_t _ptr_servername;
26898         TALLOC_CTX *_mem_save_servername_0;
26899         TALLOC_CTX *_mem_save_info_ctr_0;
26900         if (flags & NDR_IN) {
26901                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26902                 if (_ptr_servername) {
26903                         NDR_PULL_ALLOC(ndr, r->in.servername);
26904                 } else {
26905                         r->in.servername = NULL;
26906                 }
26907                 if (r->in.servername) {
26908                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26909                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26911                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26912                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26913                                 return 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));
26914                         }
26915                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26916                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26918                 }
26919                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26920                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26921                 }
26922                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26923                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26924                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26926                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
26927         }
26928         if (flags & NDR_OUT) {
26929                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26930         }
26931         return NDR_ERR_SUCCESS;
26932 }
26933
26934 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
26935 {
26936         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
26937         ndr->depth++;
26938         if (flags & NDR_SET_VALUES) {
26939                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26940         }
26941         if (flags & NDR_IN) {
26942                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
26943                 ndr->depth++;
26944                 ndr_print_ptr(ndr, "servername", r->in.servername);
26945                 ndr->depth++;
26946                 if (r->in.servername) {
26947                         ndr_print_string(ndr, "servername", r->in.servername);
26948                 }
26949                 ndr->depth--;
26950                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26951                 ndr->depth++;
26952                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26953                 ndr->depth--;
26954                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
26955                 ndr->depth--;
26956         }
26957         if (flags & NDR_OUT) {
26958                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
26959                 ndr->depth++;
26960                 ndr_print_WERROR(ndr, "result", r->out.result);
26961                 ndr->depth--;
26962         }
26963         ndr->depth--;
26964 }
26965
26966 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
26967 {
26968         if (flags & NDR_IN) {
26969         }
26970         if (flags & NDR_OUT) {
26971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26972         }
26973         return NDR_ERR_SUCCESS;
26974 }
26975
26976 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
26977 {
26978         if (flags & NDR_IN) {
26979         }
26980         if (flags & NDR_OUT) {
26981                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26982         }
26983         return NDR_ERR_SUCCESS;
26984 }
26985
26986 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
26987 {
26988         ndr_print_struct(ndr, name, "spoolss_5a");
26989         ndr->depth++;
26990         if (flags & NDR_SET_VALUES) {
26991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26992         }
26993         if (flags & NDR_IN) {
26994                 ndr_print_struct(ndr, "in", "spoolss_5a");
26995                 ndr->depth++;
26996                 ndr->depth--;
26997         }
26998         if (flags & NDR_OUT) {
26999                 ndr_print_struct(ndr, "out", "spoolss_5a");
27000                 ndr->depth++;
27001                 ndr_print_WERROR(ndr, "result", r->out.result);
27002                 ndr->depth--;
27003         }
27004         ndr->depth--;
27005 }
27006
27007 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27008 {
27009         if (flags & NDR_IN) {
27010         }
27011         if (flags & NDR_OUT) {
27012                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27013         }
27014         return NDR_ERR_SUCCESS;
27015 }
27016
27017 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27018 {
27019         if (flags & NDR_IN) {
27020         }
27021         if (flags & NDR_OUT) {
27022                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27023         }
27024         return NDR_ERR_SUCCESS;
27025 }
27026
27027 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27028 {
27029         ndr_print_struct(ndr, name, "spoolss_5b");
27030         ndr->depth++;
27031         if (flags & NDR_SET_VALUES) {
27032                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27033         }
27034         if (flags & NDR_IN) {
27035                 ndr_print_struct(ndr, "in", "spoolss_5b");
27036                 ndr->depth++;
27037                 ndr->depth--;
27038         }
27039         if (flags & NDR_OUT) {
27040                 ndr_print_struct(ndr, "out", "spoolss_5b");
27041                 ndr->depth++;
27042                 ndr_print_WERROR(ndr, "result", r->out.result);
27043                 ndr->depth--;
27044         }
27045         ndr->depth--;
27046 }
27047
27048 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27049 {
27050         if (flags & NDR_IN) {
27051         }
27052         if (flags & NDR_OUT) {
27053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27054         }
27055         return NDR_ERR_SUCCESS;
27056 }
27057
27058 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27059 {
27060         if (flags & NDR_IN) {
27061         }
27062         if (flags & NDR_OUT) {
27063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27064         }
27065         return NDR_ERR_SUCCESS;
27066 }
27067
27068 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27069 {
27070         ndr_print_struct(ndr, name, "spoolss_5c");
27071         ndr->depth++;
27072         if (flags & NDR_SET_VALUES) {
27073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27074         }
27075         if (flags & NDR_IN) {
27076                 ndr_print_struct(ndr, "in", "spoolss_5c");
27077                 ndr->depth++;
27078                 ndr->depth--;
27079         }
27080         if (flags & NDR_OUT) {
27081                 ndr_print_struct(ndr, "out", "spoolss_5c");
27082                 ndr->depth++;
27083                 ndr_print_WERROR(ndr, "result", r->out.result);
27084                 ndr->depth--;
27085         }
27086         ndr->depth--;
27087 }
27088
27089 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27090 {
27091         if (flags & NDR_IN) {
27092         }
27093         if (flags & NDR_OUT) {
27094                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27095         }
27096         return NDR_ERR_SUCCESS;
27097 }
27098
27099 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27100 {
27101         if (flags & NDR_IN) {
27102         }
27103         if (flags & NDR_OUT) {
27104                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27105         }
27106         return NDR_ERR_SUCCESS;
27107 }
27108
27109 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27110 {
27111         ndr_print_struct(ndr, name, "spoolss_5d");
27112         ndr->depth++;
27113         if (flags & NDR_SET_VALUES) {
27114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27115         }
27116         if (flags & NDR_IN) {
27117                 ndr_print_struct(ndr, "in", "spoolss_5d");
27118                 ndr->depth++;
27119                 ndr->depth--;
27120         }
27121         if (flags & NDR_OUT) {
27122                 ndr_print_struct(ndr, "out", "spoolss_5d");
27123                 ndr->depth++;
27124                 ndr_print_WERROR(ndr, "result", r->out.result);
27125                 ndr->depth--;
27126         }
27127         ndr->depth--;
27128 }
27129
27130 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27131 {
27132         if (flags & NDR_IN) {
27133         }
27134         if (flags & NDR_OUT) {
27135                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27136         }
27137         return NDR_ERR_SUCCESS;
27138 }
27139
27140 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27141 {
27142         if (flags & NDR_IN) {
27143         }
27144         if (flags & NDR_OUT) {
27145                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27146         }
27147         return NDR_ERR_SUCCESS;
27148 }
27149
27150 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27151 {
27152         ndr_print_struct(ndr, name, "spoolss_5e");
27153         ndr->depth++;
27154         if (flags & NDR_SET_VALUES) {
27155                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27156         }
27157         if (flags & NDR_IN) {
27158                 ndr_print_struct(ndr, "in", "spoolss_5e");
27159                 ndr->depth++;
27160                 ndr->depth--;
27161         }
27162         if (flags & NDR_OUT) {
27163                 ndr_print_struct(ndr, "out", "spoolss_5e");
27164                 ndr->depth++;
27165                 ndr_print_WERROR(ndr, "result", r->out.result);
27166                 ndr->depth--;
27167         }
27168         ndr->depth--;
27169 }
27170
27171 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27172 {
27173         if (flags & NDR_IN) {
27174         }
27175         if (flags & NDR_OUT) {
27176                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27177         }
27178         return NDR_ERR_SUCCESS;
27179 }
27180
27181 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27182 {
27183         if (flags & NDR_IN) {
27184         }
27185         if (flags & NDR_OUT) {
27186                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27187         }
27188         return NDR_ERR_SUCCESS;
27189 }
27190
27191 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27192 {
27193         ndr_print_struct(ndr, name, "spoolss_5f");
27194         ndr->depth++;
27195         if (flags & NDR_SET_VALUES) {
27196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27197         }
27198         if (flags & NDR_IN) {
27199                 ndr_print_struct(ndr, "in", "spoolss_5f");
27200                 ndr->depth++;
27201                 ndr->depth--;
27202         }
27203         if (flags & NDR_OUT) {
27204                 ndr_print_struct(ndr, "out", "spoolss_5f");
27205                 ndr->depth++;
27206                 ndr_print_WERROR(ndr, "result", r->out.result);
27207                 ndr->depth--;
27208         }
27209         ndr->depth--;
27210 }
27211
27212 static const struct ndr_interface_call spoolss_calls[] = {
27213         {
27214                 "spoolss_EnumPrinters",
27215                 sizeof(struct spoolss_EnumPrinters),
27216                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27217                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27218                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27219                 false,
27220         },
27221         {
27222                 "spoolss_OpenPrinter",
27223                 sizeof(struct spoolss_OpenPrinter),
27224                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27225                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27226                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27227                 false,
27228         },
27229         {
27230                 "spoolss_SetJob",
27231                 sizeof(struct spoolss_SetJob),
27232                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27233                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27234                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27235                 false,
27236         },
27237         {
27238                 "spoolss_GetJob",
27239                 sizeof(struct spoolss_GetJob),
27240                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27241                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27242                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27243                 false,
27244         },
27245         {
27246                 "spoolss_EnumJobs",
27247                 sizeof(struct spoolss_EnumJobs),
27248                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27249                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27250                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27251                 false,
27252         },
27253         {
27254                 "spoolss_AddPrinter",
27255                 sizeof(struct spoolss_AddPrinter),
27256                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27257                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27258                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27259                 false,
27260         },
27261         {
27262                 "spoolss_DeletePrinter",
27263                 sizeof(struct spoolss_DeletePrinter),
27264                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27265                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27266                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27267                 false,
27268         },
27269         {
27270                 "spoolss_SetPrinter",
27271                 sizeof(struct spoolss_SetPrinter),
27272                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27273                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27274                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27275                 false,
27276         },
27277         {
27278                 "spoolss_GetPrinter",
27279                 sizeof(struct spoolss_GetPrinter),
27280                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27281                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27282                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27283                 false,
27284         },
27285         {
27286                 "spoolss_AddPrinterDriver",
27287                 sizeof(struct spoolss_AddPrinterDriver),
27288                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27289                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27290                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27291                 false,
27292         },
27293         {
27294                 "spoolss_EnumPrinterDrivers",
27295                 sizeof(struct spoolss_EnumPrinterDrivers),
27296                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27297                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27298                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27299                 false,
27300         },
27301         {
27302                 "spoolss_GetPrinterDriver",
27303                 sizeof(struct spoolss_GetPrinterDriver),
27304                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27305                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27306                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27307                 false,
27308         },
27309         {
27310                 "spoolss_GetPrinterDriverDirectory",
27311                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27312                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27313                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27314                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27315                 false,
27316         },
27317         {
27318                 "spoolss_DeletePrinterDriver",
27319                 sizeof(struct spoolss_DeletePrinterDriver),
27320                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27321                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27322                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27323                 false,
27324         },
27325         {
27326                 "spoolss_AddPrintProcessor",
27327                 sizeof(struct spoolss_AddPrintProcessor),
27328                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27329                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27330                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27331                 false,
27332         },
27333         {
27334                 "spoolss_EnumPrintProcessors",
27335                 sizeof(struct spoolss_EnumPrintProcessors),
27336                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27337                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27338                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27339                 false,
27340         },
27341         {
27342                 "spoolss_GetPrintProcessorDirectory",
27343                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27344                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27345                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27346                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27347                 false,
27348         },
27349         {
27350                 "spoolss_StartDocPrinter",
27351                 sizeof(struct spoolss_StartDocPrinter),
27352                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27353                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27354                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27355                 false,
27356         },
27357         {
27358                 "spoolss_StartPagePrinter",
27359                 sizeof(struct spoolss_StartPagePrinter),
27360                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27361                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27362                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27363                 false,
27364         },
27365         {
27366                 "spoolss_WritePrinter",
27367                 sizeof(struct spoolss_WritePrinter),
27368                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27369                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27370                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27371                 false,
27372         },
27373         {
27374                 "spoolss_EndPagePrinter",
27375                 sizeof(struct spoolss_EndPagePrinter),
27376                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27377                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27378                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27379                 false,
27380         },
27381         {
27382                 "spoolss_AbortPrinter",
27383                 sizeof(struct spoolss_AbortPrinter),
27384                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27385                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27386                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27387                 false,
27388         },
27389         {
27390                 "spoolss_ReadPrinter",
27391                 sizeof(struct spoolss_ReadPrinter),
27392                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27393                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27394                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27395                 false,
27396         },
27397         {
27398                 "spoolss_EndDocPrinter",
27399                 sizeof(struct spoolss_EndDocPrinter),
27400                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27401                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27402                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27403                 false,
27404         },
27405         {
27406                 "spoolss_AddJob",
27407                 sizeof(struct spoolss_AddJob),
27408                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27409                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27410                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27411                 false,
27412         },
27413         {
27414                 "spoolss_ScheduleJob",
27415                 sizeof(struct spoolss_ScheduleJob),
27416                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27417                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27418                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27419                 false,
27420         },
27421         {
27422                 "spoolss_GetPrinterData",
27423                 sizeof(struct spoolss_GetPrinterData),
27424                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27425                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27426                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27427                 false,
27428         },
27429         {
27430                 "spoolss_SetPrinterData",
27431                 sizeof(struct spoolss_SetPrinterData),
27432                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27433                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27434                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27435                 false,
27436         },
27437         {
27438                 "spoolss_WaitForPrinterChange",
27439                 sizeof(struct spoolss_WaitForPrinterChange),
27440                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27441                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27442                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27443                 false,
27444         },
27445         {
27446                 "spoolss_ClosePrinter",
27447                 sizeof(struct spoolss_ClosePrinter),
27448                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27449                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27450                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27451                 false,
27452         },
27453         {
27454                 "spoolss_AddForm",
27455                 sizeof(struct spoolss_AddForm),
27456                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27457                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27458                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27459                 false,
27460         },
27461         {
27462                 "spoolss_DeleteForm",
27463                 sizeof(struct spoolss_DeleteForm),
27464                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27465                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27466                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27467                 false,
27468         },
27469         {
27470                 "spoolss_GetForm",
27471                 sizeof(struct spoolss_GetForm),
27472                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27473                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27474                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27475                 false,
27476         },
27477         {
27478                 "spoolss_SetForm",
27479                 sizeof(struct spoolss_SetForm),
27480                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27481                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27482                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27483                 false,
27484         },
27485         {
27486                 "spoolss_EnumForms",
27487                 sizeof(struct spoolss_EnumForms),
27488                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27489                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27490                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27491                 false,
27492         },
27493         {
27494                 "spoolss_EnumPorts",
27495                 sizeof(struct spoolss_EnumPorts),
27496                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27497                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27498                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27499                 false,
27500         },
27501         {
27502                 "spoolss_EnumMonitors",
27503                 sizeof(struct spoolss_EnumMonitors),
27504                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27505                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27506                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27507                 false,
27508         },
27509         {
27510                 "spoolss_AddPort",
27511                 sizeof(struct spoolss_AddPort),
27512                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27513                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27514                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27515                 false,
27516         },
27517         {
27518                 "spoolss_ConfigurePort",
27519                 sizeof(struct spoolss_ConfigurePort),
27520                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27521                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27522                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27523                 false,
27524         },
27525         {
27526                 "spoolss_DeletePort",
27527                 sizeof(struct spoolss_DeletePort),
27528                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27529                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27530                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27531                 false,
27532         },
27533         {
27534                 "spoolss_CreatePrinterIC",
27535                 sizeof(struct spoolss_CreatePrinterIC),
27536                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27537                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27538                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27539                 false,
27540         },
27541         {
27542                 "spoolss_PlayGDIScriptOnPrinterIC",
27543                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27544                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27545                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27546                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27547                 false,
27548         },
27549         {
27550                 "spoolss_DeletePrinterIC",
27551                 sizeof(struct spoolss_DeletePrinterIC),
27552                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27553                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27554                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27555                 false,
27556         },
27557         {
27558                 "spoolss_AddPrinterConnection",
27559                 sizeof(struct spoolss_AddPrinterConnection),
27560                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27561                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27562                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27563                 false,
27564         },
27565         {
27566                 "spoolss_DeletePrinterConnection",
27567                 sizeof(struct spoolss_DeletePrinterConnection),
27568                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27569                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27570                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27571                 false,
27572         },
27573         {
27574                 "spoolss_PrinterMessageBox",
27575                 sizeof(struct spoolss_PrinterMessageBox),
27576                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27577                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27578                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27579                 false,
27580         },
27581         {
27582                 "spoolss_AddMonitor",
27583                 sizeof(struct spoolss_AddMonitor),
27584                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27585                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27586                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27587                 false,
27588         },
27589         {
27590                 "spoolss_DeleteMonitor",
27591                 sizeof(struct spoolss_DeleteMonitor),
27592                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27593                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27594                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27595                 false,
27596         },
27597         {
27598                 "spoolss_DeletePrintProcessor",
27599                 sizeof(struct spoolss_DeletePrintProcessor),
27600                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27601                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27602                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27603                 false,
27604         },
27605         {
27606                 "spoolss_AddPrintProvidor",
27607                 sizeof(struct spoolss_AddPrintProvidor),
27608                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27609                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27610                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27611                 false,
27612         },
27613         {
27614                 "spoolss_DeletePrintProvidor",
27615                 sizeof(struct spoolss_DeletePrintProvidor),
27616                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27617                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27618                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27619                 false,
27620         },
27621         {
27622                 "spoolss_EnumPrintProcDataTypes",
27623                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27624                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27625                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27626                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27627                 false,
27628         },
27629         {
27630                 "spoolss_ResetPrinter",
27631                 sizeof(struct spoolss_ResetPrinter),
27632                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27633                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27634                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27635                 false,
27636         },
27637         {
27638                 "spoolss_GetPrinterDriver2",
27639                 sizeof(struct spoolss_GetPrinterDriver2),
27640                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27641                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27642                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27643                 false,
27644         },
27645         {
27646                 "spoolss_FindFirstPrinterChangeNotification",
27647                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27648                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27649                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27650                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27651                 false,
27652         },
27653         {
27654                 "spoolss_FindNextPrinterChangeNotification",
27655                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27656                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27657                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27658                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27659                 false,
27660         },
27661         {
27662                 "spoolss_FindClosePrinterNotify",
27663                 sizeof(struct spoolss_FindClosePrinterNotify),
27664                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27665                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27666                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27667                 false,
27668         },
27669         {
27670                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27671                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27672                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27673                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27674                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27675                 false,
27676         },
27677         {
27678                 "spoolss_ReplyOpenPrinter",
27679                 sizeof(struct spoolss_ReplyOpenPrinter),
27680                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27681                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27682                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27683                 false,
27684         },
27685         {
27686                 "spoolss_RouterReplyPrinter",
27687                 sizeof(struct spoolss_RouterReplyPrinter),
27688                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27689                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27690                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27691                 false,
27692         },
27693         {
27694                 "spoolss_ReplyClosePrinter",
27695                 sizeof(struct spoolss_ReplyClosePrinter),
27696                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27697                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27698                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27699                 false,
27700         },
27701         {
27702                 "spoolss_AddPortEx",
27703                 sizeof(struct spoolss_AddPortEx),
27704                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27705                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27706                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27707                 false,
27708         },
27709         {
27710                 "spoolss_RouterFindFirstPrinterChangeNotification",
27711                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27712                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27713                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27714                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27715                 false,
27716         },
27717         {
27718                 "spoolss_SpoolerInit",
27719                 sizeof(struct spoolss_SpoolerInit),
27720                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27721                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27722                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27723                 false,
27724         },
27725         {
27726                 "spoolss_ResetPrinterEx",
27727                 sizeof(struct spoolss_ResetPrinterEx),
27728                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27729                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27730                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27731                 false,
27732         },
27733         {
27734                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27735                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27736                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27737                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27738                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27739                 false,
27740         },
27741         {
27742                 "spoolss_RouterReplyPrinterEx",
27743                 sizeof(struct spoolss_RouterReplyPrinterEx),
27744                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27745                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27746                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27747                 false,
27748         },
27749         {
27750                 "spoolss_RouterRefreshPrinterChangeNotify",
27751                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27752                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27753                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27754                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27755                 false,
27756         },
27757         {
27758                 "spoolss_44",
27759                 sizeof(struct spoolss_44),
27760                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27761                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27762                 (ndr_print_function_t) ndr_print_spoolss_44,
27763                 false,
27764         },
27765         {
27766                 "spoolss_OpenPrinterEx",
27767                 sizeof(struct spoolss_OpenPrinterEx),
27768                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27769                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27770                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27771                 false,
27772         },
27773         {
27774                 "spoolss_AddPrinterEx",
27775                 sizeof(struct spoolss_AddPrinterEx),
27776                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27777                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27778                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27779                 false,
27780         },
27781         {
27782                 "spoolss_47",
27783                 sizeof(struct spoolss_47),
27784                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27785                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27786                 (ndr_print_function_t) ndr_print_spoolss_47,
27787                 false,
27788         },
27789         {
27790                 "spoolss_EnumPrinterData",
27791                 sizeof(struct spoolss_EnumPrinterData),
27792                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27793                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27794                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27795                 false,
27796         },
27797         {
27798                 "spoolss_DeletePrinterData",
27799                 sizeof(struct spoolss_DeletePrinterData),
27800                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27801                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27802                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27803                 false,
27804         },
27805         {
27806                 "spoolss_4a",
27807                 sizeof(struct spoolss_4a),
27808                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27809                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27810                 (ndr_print_function_t) ndr_print_spoolss_4a,
27811                 false,
27812         },
27813         {
27814                 "spoolss_4b",
27815                 sizeof(struct spoolss_4b),
27816                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27817                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27818                 (ndr_print_function_t) ndr_print_spoolss_4b,
27819                 false,
27820         },
27821         {
27822                 "spoolss_4c",
27823                 sizeof(struct spoolss_4c),
27824                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27825                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27826                 (ndr_print_function_t) ndr_print_spoolss_4c,
27827                 false,
27828         },
27829         {
27830                 "spoolss_SetPrinterDataEx",
27831                 sizeof(struct spoolss_SetPrinterDataEx),
27832                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27833                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27834                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27835                 false,
27836         },
27837         {
27838                 "spoolss_GetPrinterDataEx",
27839                 sizeof(struct spoolss_GetPrinterDataEx),
27840                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27841                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27842                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27843                 false,
27844         },
27845         {
27846                 "spoolss_EnumPrinterDataEx",
27847                 sizeof(struct spoolss_EnumPrinterDataEx),
27848                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27849                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27850                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27851                 false,
27852         },
27853         {
27854                 "spoolss_EnumPrinterKey",
27855                 sizeof(struct spoolss_EnumPrinterKey),
27856                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27857                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27858                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27859                 false,
27860         },
27861         {
27862                 "spoolss_DeletePrinterDataEx",
27863                 sizeof(struct spoolss_DeletePrinterDataEx),
27864                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27865                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27866                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27867                 false,
27868         },
27869         {
27870                 "spoolss_DeletePrinterKey",
27871                 sizeof(struct spoolss_DeletePrinterKey),
27872                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27873                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27874                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27875                 false,
27876         },
27877         {
27878                 "spoolss_53",
27879                 sizeof(struct spoolss_53),
27880                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27881                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27882                 (ndr_print_function_t) ndr_print_spoolss_53,
27883                 false,
27884         },
27885         {
27886                 "spoolss_DeletePrinterDriverEx",
27887                 sizeof(struct spoolss_DeletePrinterDriverEx),
27888                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27889                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27890                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27891                 false,
27892         },
27893         {
27894                 "spoolss_55",
27895                 sizeof(struct spoolss_55),
27896                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
27897                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
27898                 (ndr_print_function_t) ndr_print_spoolss_55,
27899                 false,
27900         },
27901         {
27902                 "spoolss_56",
27903                 sizeof(struct spoolss_56),
27904                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
27905                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
27906                 (ndr_print_function_t) ndr_print_spoolss_56,
27907                 false,
27908         },
27909         {
27910                 "spoolss_57",
27911                 sizeof(struct spoolss_57),
27912                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
27913                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
27914                 (ndr_print_function_t) ndr_print_spoolss_57,
27915                 false,
27916         },
27917         {
27918                 "spoolss_XcvData",
27919                 sizeof(struct spoolss_XcvData),
27920                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
27921                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
27922                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
27923                 false,
27924         },
27925         {
27926                 "spoolss_AddPrinterDriverEx",
27927                 sizeof(struct spoolss_AddPrinterDriverEx),
27928                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
27929                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
27930                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
27931                 false,
27932         },
27933         {
27934                 "spoolss_5a",
27935                 sizeof(struct spoolss_5a),
27936                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
27937                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
27938                 (ndr_print_function_t) ndr_print_spoolss_5a,
27939                 false,
27940         },
27941         {
27942                 "spoolss_5b",
27943                 sizeof(struct spoolss_5b),
27944                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
27945                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
27946                 (ndr_print_function_t) ndr_print_spoolss_5b,
27947                 false,
27948         },
27949         {
27950                 "spoolss_5c",
27951                 sizeof(struct spoolss_5c),
27952                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
27953                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
27954                 (ndr_print_function_t) ndr_print_spoolss_5c,
27955                 false,
27956         },
27957         {
27958                 "spoolss_5d",
27959                 sizeof(struct spoolss_5d),
27960                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
27961                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
27962                 (ndr_print_function_t) ndr_print_spoolss_5d,
27963                 false,
27964         },
27965         {
27966                 "spoolss_5e",
27967                 sizeof(struct spoolss_5e),
27968                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
27969                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
27970                 (ndr_print_function_t) ndr_print_spoolss_5e,
27971                 false,
27972         },
27973         {
27974                 "spoolss_5f",
27975                 sizeof(struct spoolss_5f),
27976                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
27977                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
27978                 (ndr_print_function_t) ndr_print_spoolss_5f,
27979                 false,
27980         },
27981         { NULL, 0, NULL, NULL, NULL, false }
27982 };
27983
27984 static const char * const spoolss_endpoint_strings[] = {
27985         "ncacn_np:[\\pipe\\spoolss]",
27986 };
27987
27988 static const struct ndr_interface_string_array spoolss_endpoints = {
27989         .count  = 1,
27990         .names  = spoolss_endpoint_strings
27991 };
27992
27993 static const char * const spoolss_authservice_strings[] = {
27994         "host",
27995 };
27996
27997 static const struct ndr_interface_string_array spoolss_authservices = {
27998         .count  = 1,
27999         .names  = spoolss_authservice_strings
28000 };
28001
28002
28003 const struct ndr_interface_table ndr_table_spoolss = {
28004         .name           = "spoolss",
28005         .syntax_id      = {
28006                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28007                 NDR_SPOOLSS_VERSION
28008         },
28009         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28010         .num_calls      = 96,
28011         .calls          = spoolss_calls,
28012         .endpoints      = &spoolss_endpoints,
28013         .authservices   = &spoolss_authservices
28014 };
28015