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 static 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 static 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_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13830 {
13831         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13832         if (ndr_flags & NDR_SCALARS) {
13833                 int level = ndr_push_get_switch_value(ndr, r);
13834                 switch (level) {
13835                         case 1: {
13836                                 NDR_CHECK(ndr_push_align(ndr, 4));
13837                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13838                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13839                         break; }
13840
13841                         default: {
13842                         break; }
13843
13844                 }
13845         }
13846         if (ndr_flags & NDR_BUFFERS) {
13847                 int level = ndr_push_get_switch_value(ndr, r);
13848                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13849                 switch (level) {
13850                         case 1:
13851                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13852                         break;
13853
13854                         default:
13855                         break;
13856
13857                 }
13858         }
13859         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13860         return NDR_ERR_SUCCESS;
13861 }
13862
13863 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13864 {
13865         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13866         int level;
13867         level = ndr_pull_get_switch_value(ndr, r);
13868         if (ndr_flags & NDR_SCALARS) {
13869                 switch (level) {
13870                         case 1: {
13871                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13872                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13873                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13874                         break; }
13875
13876                         default: {
13877                         break; }
13878
13879                 }
13880         }
13881         if (ndr_flags & NDR_BUFFERS) {
13882                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13883                 switch (level) {
13884                         case 1:
13885                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13886                         break;
13887
13888                         default:
13889                         break;
13890
13891                 }
13892         }
13893         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13894         return NDR_ERR_SUCCESS;
13895 }
13896
13897 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13898 {
13899         int level;
13900         level = ndr_print_get_switch_value(ndr, r);
13901         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13902         switch (level) {
13903                 case 1:
13904                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13905                 break;
13906
13907                 default:
13908                 break;
13909
13910         }
13911 }
13912
13913 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13914 {
13915         if (ndr_flags & NDR_SCALARS) {
13916                 NDR_CHECK(ndr_push_align(ndr, 4));
13917                 {
13918                         uint32_t _flags_save_string = ndr->flags;
13919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13920                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13921                         ndr->flags = _flags_save_string;
13922                 }
13923         }
13924         if (ndr_flags & NDR_BUFFERS) {
13925         }
13926         return NDR_ERR_SUCCESS;
13927 }
13928
13929 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
13930 {
13931         if (ndr_flags & NDR_SCALARS) {
13932                 NDR_CHECK(ndr_pull_align(ndr, 4));
13933                 {
13934                         uint32_t _flags_save_string = ndr->flags;
13935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13936                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13937                         ndr->flags = _flags_save_string;
13938                 }
13939         }
13940         if (ndr_flags & NDR_BUFFERS) {
13941         }
13942         return NDR_ERR_SUCCESS;
13943 }
13944
13945 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13946 {
13947         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
13948         ndr->depth++;
13949         ndr_print_string(ndr, "directory_name", r->directory_name);
13950         ndr->depth--;
13951 }
13952
13953 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13954 {
13955         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
13956 }
13957
13958 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
13959 {
13960         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13961         if (ndr_flags & NDR_SCALARS) {
13962                 int level = ndr_push_get_switch_value(ndr, r);
13963                 switch (level) {
13964                         case 1: {
13965                                 NDR_CHECK(ndr_push_align(ndr, 4));
13966                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13967                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13968                         break; }
13969
13970                         default: {
13971                                 NDR_CHECK(ndr_push_align(ndr, 4));
13972                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13973                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13974                         break; }
13975
13976                 }
13977         }
13978         if (ndr_flags & NDR_BUFFERS) {
13979                 int level = ndr_push_get_switch_value(ndr, r);
13980                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13981                 switch (level) {
13982                         case 1:
13983                         break;
13984
13985                         default:
13986                         break;
13987
13988                 }
13989         }
13990         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13991         return NDR_ERR_SUCCESS;
13992 }
13993
13994 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
13995 {
13996         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13997         int level;
13998         level = ndr_pull_get_switch_value(ndr, r);
13999         if (ndr_flags & NDR_SCALARS) {
14000                 switch (level) {
14001                         case 1: {
14002                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14003                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14004                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14005                         break; }
14006
14007                         default: {
14008                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14009                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14010                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14011                         break; }
14012
14013                 }
14014         }
14015         if (ndr_flags & NDR_BUFFERS) {
14016                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14017                 switch (level) {
14018                         case 1:
14019                         break;
14020
14021                         default:
14022                         break;
14023
14024                 }
14025         }
14026         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14027         return NDR_ERR_SUCCESS;
14028 }
14029
14030 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14031 {
14032         int level;
14033         level = ndr_print_get_switch_value(ndr, r);
14034         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14035         switch (level) {
14036                 case 1:
14037                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14038                 break;
14039
14040                 default:
14041                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14042                 break;
14043
14044         }
14045 }
14046
14047 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14048 {
14049         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14050 }
14051
14052 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14053 {
14054         if (ndr_flags & NDR_SCALARS) {
14055                 NDR_CHECK(ndr_push_align(ndr, 4));
14056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14059         }
14060         if (ndr_flags & NDR_BUFFERS) {
14061                 if (r->document_name) {
14062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14066                 }
14067                 if (r->output_file) {
14068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14072                 }
14073                 if (r->datatype) {
14074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14078                 }
14079         }
14080         return NDR_ERR_SUCCESS;
14081 }
14082
14083 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14084 {
14085         uint32_t _ptr_document_name;
14086         TALLOC_CTX *_mem_save_document_name_0;
14087         uint32_t _ptr_output_file;
14088         TALLOC_CTX *_mem_save_output_file_0;
14089         uint32_t _ptr_datatype;
14090         TALLOC_CTX *_mem_save_datatype_0;
14091         if (ndr_flags & NDR_SCALARS) {
14092                 NDR_CHECK(ndr_pull_align(ndr, 4));
14093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14094                 if (_ptr_document_name) {
14095                         NDR_PULL_ALLOC(ndr, r->document_name);
14096                 } else {
14097                         r->document_name = NULL;
14098                 }
14099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14100                 if (_ptr_output_file) {
14101                         NDR_PULL_ALLOC(ndr, r->output_file);
14102                 } else {
14103                         r->output_file = NULL;
14104                 }
14105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14106                 if (_ptr_datatype) {
14107                         NDR_PULL_ALLOC(ndr, r->datatype);
14108                 } else {
14109                         r->datatype = NULL;
14110                 }
14111         }
14112         if (ndr_flags & NDR_BUFFERS) {
14113                 if (r->document_name) {
14114                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14115                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14118                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14119                                 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));
14120                         }
14121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14124                 }
14125                 if (r->output_file) {
14126                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14127                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14130                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14131                                 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));
14132                         }
14133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14136                 }
14137                 if (r->datatype) {
14138                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14139                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14142                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14143                                 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));
14144                         }
14145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14148                 }
14149         }
14150         return NDR_ERR_SUCCESS;
14151 }
14152
14153 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14154 {
14155         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14156         ndr->depth++;
14157         ndr_print_ptr(ndr, "document_name", r->document_name);
14158         ndr->depth++;
14159         if (r->document_name) {
14160                 ndr_print_string(ndr, "document_name", r->document_name);
14161         }
14162         ndr->depth--;
14163         ndr_print_ptr(ndr, "output_file", r->output_file);
14164         ndr->depth++;
14165         if (r->output_file) {
14166                 ndr_print_string(ndr, "output_file", r->output_file);
14167         }
14168         ndr->depth--;
14169         ndr_print_ptr(ndr, "datatype", r->datatype);
14170         ndr->depth++;
14171         if (r->datatype) {
14172                 ndr_print_string(ndr, "datatype", r->datatype);
14173         }
14174         ndr->depth--;
14175         ndr->depth--;
14176 }
14177
14178 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14179 {
14180         if (ndr_flags & NDR_SCALARS) {
14181                 int level = ndr_push_get_switch_value(ndr, r);
14182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14183                 switch (level) {
14184                         case 1: {
14185                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14186                         break; }
14187
14188                         case 2: {
14189                         break; }
14190
14191                         case 3: {
14192                         break; }
14193
14194                         default: {
14195                         break; }
14196
14197                 }
14198         }
14199         if (ndr_flags & NDR_BUFFERS) {
14200                 int level = ndr_push_get_switch_value(ndr, r);
14201                 switch (level) {
14202                         case 1:
14203                                 if (r->info1) {
14204                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14205                                 }
14206                         break;
14207
14208                         case 2:
14209                         break;
14210
14211                         case 3:
14212                         break;
14213
14214                         default:
14215                         break;
14216
14217                 }
14218         }
14219         return NDR_ERR_SUCCESS;
14220 }
14221
14222 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14223 {
14224         int level;
14225         uint32_t _level;
14226         TALLOC_CTX *_mem_save_info1_0;
14227         level = ndr_pull_get_switch_value(ndr, r);
14228         if (ndr_flags & NDR_SCALARS) {
14229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14230                 if (_level != level) {
14231                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14232                 }
14233                 switch (level) {
14234                         case 1: {
14235                                 uint32_t _ptr_info1;
14236                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14237                                 if (_ptr_info1) {
14238                                         NDR_PULL_ALLOC(ndr, r->info1);
14239                                 } else {
14240                                         r->info1 = NULL;
14241                                 }
14242                         break; }
14243
14244                         case 2: {
14245                         break; }
14246
14247                         case 3: {
14248                         break; }
14249
14250                         default: {
14251                         break; }
14252
14253                 }
14254         }
14255         if (ndr_flags & NDR_BUFFERS) {
14256                 switch (level) {
14257                         case 1:
14258                                 if (r->info1) {
14259                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14260                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14261                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14262                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14263                                 }
14264                         break;
14265
14266                         case 2:
14267                         break;
14268
14269                         case 3:
14270                         break;
14271
14272                         default:
14273                         break;
14274
14275                 }
14276         }
14277         return NDR_ERR_SUCCESS;
14278 }
14279
14280 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14281 {
14282         int level;
14283         level = ndr_print_get_switch_value(ndr, r);
14284         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14285         switch (level) {
14286                 case 1:
14287                         ndr_print_ptr(ndr, "info1", r->info1);
14288                         ndr->depth++;
14289                         if (r->info1) {
14290                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14291                         }
14292                         ndr->depth--;
14293                 break;
14294
14295                 case 2:
14296                 break;
14297
14298                 case 3:
14299                 break;
14300
14301                 default:
14302                 break;
14303
14304         }
14305 }
14306
14307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14308 {
14309         if (ndr_flags & NDR_SCALARS) {
14310                 NDR_CHECK(ndr_push_align(ndr, 4));
14311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14316                 {
14317                         uint32_t _flags_save_string = ndr->flags;
14318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14319                         {
14320                                 struct ndr_push *_ndr_extra_string;
14321                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14322                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14323                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14324                         }
14325                         ndr->flags = _flags_save_string;
14326                 }
14327         }
14328         if (ndr_flags & NDR_BUFFERS) {
14329         }
14330         return NDR_ERR_SUCCESS;
14331 }
14332
14333 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14334 {
14335         if (ndr_flags & NDR_SCALARS) {
14336                 NDR_CHECK(ndr_pull_align(ndr, 4));
14337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14342                 {
14343                         uint32_t _flags_save_string = ndr->flags;
14344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14345                         {
14346                                 struct ndr_pull *_ndr_extra_string;
14347                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14348                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14349                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14350                         }
14351                         ndr->flags = _flags_save_string;
14352                 }
14353         }
14354         if (ndr_flags & NDR_BUFFERS) {
14355         }
14356         return NDR_ERR_SUCCESS;
14357 }
14358
14359 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14360 {
14361         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14362         ndr->depth++;
14363         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);
14364         ndr_print_uint32(ndr, "major", r->major);
14365         ndr_print_uint32(ndr, "minor", r->minor);
14366         ndr_print_uint32(ndr, "build", r->build);
14367         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14368         ndr_print_string(ndr, "extra_string", r->extra_string);
14369         ndr->depth--;
14370 }
14371
14372 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14373 {
14374         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14375 }
14376
14377 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14378 {
14379         if (ndr_flags & NDR_SCALARS) {
14380                 NDR_CHECK(ndr_push_align(ndr, 4));
14381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14386                 {
14387                         uint32_t _flags_save_string = ndr->flags;
14388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14389                         {
14390                                 struct ndr_push *_ndr_extra_string;
14391                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14392                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14393                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14394                         }
14395                         ndr->flags = _flags_save_string;
14396                 }
14397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14399         }
14400         if (ndr_flags & NDR_BUFFERS) {
14401         }
14402         return NDR_ERR_SUCCESS;
14403 }
14404
14405 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14406 {
14407         if (ndr_flags & NDR_SCALARS) {
14408                 NDR_CHECK(ndr_pull_align(ndr, 4));
14409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14414                 {
14415                         uint32_t _flags_save_string = ndr->flags;
14416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14417                         {
14418                                 struct ndr_pull *_ndr_extra_string;
14419                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14420                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14421                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14422                         }
14423                         ndr->flags = _flags_save_string;
14424                 }
14425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14427         }
14428         if (ndr_flags & NDR_BUFFERS) {
14429         }
14430         return NDR_ERR_SUCCESS;
14431 }
14432
14433 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14434 {
14435         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14436         ndr->depth++;
14437         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);
14438         ndr_print_uint32(ndr, "major", r->major);
14439         ndr_print_uint32(ndr, "minor", r->minor);
14440         ndr_print_uint32(ndr, "build", r->build);
14441         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14442         ndr_print_string(ndr, "extra_string", r->extra_string);
14443         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14444         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14445         ndr->depth--;
14446 }
14447
14448 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14449 {
14450         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14451 }
14452
14453 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
14454 {
14455         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14456         return NDR_ERR_SUCCESS;
14457 }
14458
14459 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
14460 {
14461         uint32_t v;
14462         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14463         *r = v;
14464         return NDR_ERR_SUCCESS;
14465 }
14466
14467 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
14468 {
14469         const char *val = NULL;
14470
14471         switch (r) {
14472                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
14473                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
14474                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
14475                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
14476                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
14477         }
14478         ndr_print_enum(ndr, name, "ENUM", val, r);
14479 }
14480
14481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14482 {
14483         if (ndr_flags & NDR_SCALARS) {
14484                 int level = ndr_push_get_switch_value(ndr, r);
14485                 switch (level) {
14486                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14487                         break; }
14488
14489                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14490                                 {
14491                                         uint32_t _flags_save_string = ndr->flags;
14492                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14493                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14494                                         ndr->flags = _flags_save_string;
14495                                 }
14496                         break; }
14497
14498                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14499                                 {
14500                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14501                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14502                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14503                                         ndr->flags = _flags_save_DATA_BLOB;
14504                                 }
14505                         break; }
14506
14507                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14508                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14509                         break; }
14510
14511                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14512                                 {
14513                                         uint32_t _flags_save_string_array = ndr->flags;
14514                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14515                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14516                                         ndr->flags = _flags_save_string_array;
14517                                 }
14518                         break; }
14519
14520                         default: {
14521                                 {
14522                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14523                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14524                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14525                                         ndr->flags = _flags_save_DATA_BLOB;
14526                                 }
14527                         break; }
14528
14529                 }
14530         }
14531         if (ndr_flags & NDR_BUFFERS) {
14532                 int level = ndr_push_get_switch_value(ndr, r);
14533                 switch (level) {
14534                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14535                         break;
14536
14537                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14538                         break;
14539
14540                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14541                         break;
14542
14543                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14544                         break;
14545
14546                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14547                         break;
14548
14549                         default:
14550                         break;
14551
14552                 }
14553         }
14554         return NDR_ERR_SUCCESS;
14555 }
14556
14557 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14558 {
14559         int level;
14560         level = ndr_pull_get_switch_value(ndr, r);
14561         if (ndr_flags & NDR_SCALARS) {
14562                 switch (level) {
14563                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14564                         break; }
14565
14566                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14567                                 {
14568                                         uint32_t _flags_save_string = ndr->flags;
14569                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14570                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14571                                         ndr->flags = _flags_save_string;
14572                                 }
14573                         break; }
14574
14575                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14576                                 {
14577                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14578                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14579                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14580                                         ndr->flags = _flags_save_DATA_BLOB;
14581                                 }
14582                         break; }
14583
14584                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14585                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14586                         break; }
14587
14588                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14589                                 {
14590                                         uint32_t _flags_save_string_array = ndr->flags;
14591                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14592                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14593                                         ndr->flags = _flags_save_string_array;
14594                                 }
14595                         break; }
14596
14597                         default: {
14598                                 {
14599                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14600                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14601                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14602                                         ndr->flags = _flags_save_DATA_BLOB;
14603                                 }
14604                         break; }
14605
14606                 }
14607         }
14608         if (ndr_flags & NDR_BUFFERS) {
14609                 switch (level) {
14610                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14611                         break;
14612
14613                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14614                         break;
14615
14616                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14617                         break;
14618
14619                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14620                         break;
14621
14622                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14623                         break;
14624
14625                         default:
14626                         break;
14627
14628                 }
14629         }
14630         return NDR_ERR_SUCCESS;
14631 }
14632
14633 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14634 {
14635         int level;
14636         level = ndr_print_get_switch_value(ndr, r);
14637         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14638         switch (level) {
14639                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14640                 break;
14641
14642                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14643                         ndr_print_string(ndr, "string", r->string);
14644                 break;
14645
14646                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14647                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14648                 break;
14649
14650                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14651                         ndr_print_uint32(ndr, "value", r->value);
14652                 break;
14653
14654                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14655                         ndr_print_string_array(ndr, "string_array", r->string_array);
14656                 break;
14657
14658                 default:
14659                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14660                 break;
14661
14662         }
14663 }
14664
14665 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14666 {
14667         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14668 }
14669
14670 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14671 {
14672         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14673         return NDR_ERR_SUCCESS;
14674 }
14675
14676 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14677 {
14678         uint32_t v;
14679         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14680         *r = v;
14681         return NDR_ERR_SUCCESS;
14682 }
14683
14684 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14685 {
14686         const char *val = NULL;
14687
14688         switch (r) {
14689                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14690                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14691                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14692         }
14693         ndr_print_enum(ndr, name, "ENUM", val, r);
14694 }
14695
14696 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14697 {
14698         if (ndr_flags & NDR_SCALARS) {
14699                 NDR_CHECK(ndr_push_align(ndr, 4));
14700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14702         }
14703         if (ndr_flags & NDR_BUFFERS) {
14704         }
14705         return NDR_ERR_SUCCESS;
14706 }
14707
14708 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14709 {
14710         if (ndr_flags & NDR_SCALARS) {
14711                 NDR_CHECK(ndr_pull_align(ndr, 4));
14712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14714         }
14715         if (ndr_flags & NDR_BUFFERS) {
14716         }
14717         return NDR_ERR_SUCCESS;
14718 }
14719
14720 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14721 {
14722         ndr_print_struct(ndr, name, "spoolss_FormSize");
14723         ndr->depth++;
14724         ndr_print_uint32(ndr, "width", r->width);
14725         ndr_print_uint32(ndr, "height", r->height);
14726         ndr->depth--;
14727 }
14728
14729 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14730 {
14731         if (ndr_flags & NDR_SCALARS) {
14732                 NDR_CHECK(ndr_push_align(ndr, 4));
14733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14737         }
14738         if (ndr_flags & NDR_BUFFERS) {
14739         }
14740         return NDR_ERR_SUCCESS;
14741 }
14742
14743 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14744 {
14745         if (ndr_flags & NDR_SCALARS) {
14746                 NDR_CHECK(ndr_pull_align(ndr, 4));
14747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14751         }
14752         if (ndr_flags & NDR_BUFFERS) {
14753         }
14754         return NDR_ERR_SUCCESS;
14755 }
14756
14757 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14758 {
14759         ndr_print_struct(ndr, name, "spoolss_FormArea");
14760         ndr->depth++;
14761         ndr_print_uint32(ndr, "left", r->left);
14762         ndr_print_uint32(ndr, "top", r->top);
14763         ndr_print_uint32(ndr, "right", r->right);
14764         ndr_print_uint32(ndr, "bottom", r->bottom);
14765         ndr->depth--;
14766 }
14767
14768 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14769 {
14770         if (ndr_flags & NDR_SCALARS) {
14771                 NDR_CHECK(ndr_push_align(ndr, 4));
14772                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14773                 {
14774                         uint32_t _flags_save_string = ndr->flags;
14775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14776                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14777                         ndr->flags = _flags_save_string;
14778                 }
14779                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14780                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14781         }
14782         if (ndr_flags & NDR_BUFFERS) {
14783                 {
14784                         uint32_t _flags_save_string = ndr->flags;
14785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14786                         if (r->form_name) {
14787                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14788                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14789                         }
14790                         ndr->flags = _flags_save_string;
14791                 }
14792         }
14793         return NDR_ERR_SUCCESS;
14794 }
14795
14796 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14797 {
14798         uint32_t _ptr_form_name;
14799         TALLOC_CTX *_mem_save_form_name_0;
14800         if (ndr_flags & NDR_SCALARS) {
14801                 NDR_CHECK(ndr_pull_align(ndr, 4));
14802                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14803                 {
14804                         uint32_t _flags_save_string = ndr->flags;
14805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14806                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14807                         if (_ptr_form_name) {
14808                                 NDR_PULL_ALLOC(ndr, r->form_name);
14809                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14810                         } else {
14811                                 r->form_name = NULL;
14812                         }
14813                         ndr->flags = _flags_save_string;
14814                 }
14815                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14816                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14817         }
14818         if (ndr_flags & NDR_BUFFERS) {
14819                 {
14820                         uint32_t _flags_save_string = ndr->flags;
14821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14822                         if (r->form_name) {
14823                                 uint32_t _relative_save_offset;
14824                                 _relative_save_offset = ndr->offset;
14825                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14826                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14827                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14828                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14829                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14830                                 ndr->offset = _relative_save_offset;
14831                         }
14832                         ndr->flags = _flags_save_string;
14833                 }
14834         }
14835         return NDR_ERR_SUCCESS;
14836 }
14837
14838 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14839 {
14840         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14841         ndr->depth++;
14842         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14843         ndr_print_ptr(ndr, "form_name", r->form_name);
14844         ndr->depth++;
14845         if (r->form_name) {
14846                 ndr_print_string(ndr, "form_name", r->form_name);
14847         }
14848         ndr->depth--;
14849         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14850         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14851         ndr->depth--;
14852 }
14853
14854 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14855 {
14856         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14857         return NDR_ERR_SUCCESS;
14858 }
14859
14860 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14861 {
14862         uint32_t v;
14863         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14864         *r = v;
14865         return NDR_ERR_SUCCESS;
14866 }
14867
14868 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14869 {
14870         ndr_print_uint32(ndr, name, r);
14871         ndr->depth++;
14872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14875         ndr->depth--;
14876 }
14877
14878 static enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14879 {
14880         if (ndr_flags & NDR_SCALARS) {
14881                 NDR_CHECK(ndr_push_align(ndr, 4));
14882                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14883                 {
14884                         uint32_t _flags_save_string = ndr->flags;
14885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14886                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14887                         ndr->flags = _flags_save_string;
14888                 }
14889                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14890                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14891                 {
14892                         uint32_t _flags_save_string = ndr->flags;
14893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14895                         ndr->flags = _flags_save_string;
14896                 }
14897                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14898                 {
14899                         uint32_t _flags_save_string = ndr->flags;
14900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14901                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14902                         ndr->flags = _flags_save_string;
14903                 }
14904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14905                 {
14906                         uint32_t _flags_save_string = ndr->flags;
14907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14909                         ndr->flags = _flags_save_string;
14910                 }
14911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14912         }
14913         if (ndr_flags & NDR_BUFFERS) {
14914                 {
14915                         uint32_t _flags_save_string = ndr->flags;
14916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14917                         if (r->form_name) {
14918                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14919                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14920                         }
14921                         ndr->flags = _flags_save_string;
14922                 }
14923                 {
14924                         uint32_t _flags_save_string = ndr->flags;
14925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14926                         if (r->keyword) {
14927                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
14928                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
14929                         }
14930                         ndr->flags = _flags_save_string;
14931                 }
14932                 {
14933                         uint32_t _flags_save_string = ndr->flags;
14934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14935                         if (r->mui_dll) {
14936                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
14937                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
14938                         }
14939                         ndr->flags = _flags_save_string;
14940                 }
14941                 {
14942                         uint32_t _flags_save_string = ndr->flags;
14943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14944                         if (r->display_name) {
14945                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
14946                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
14947                         }
14948                         ndr->flags = _flags_save_string;
14949                 }
14950         }
14951         return NDR_ERR_SUCCESS;
14952 }
14953
14954 static enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
14955 {
14956         uint32_t _ptr_form_name;
14957         TALLOC_CTX *_mem_save_form_name_0;
14958         uint32_t _ptr_keyword;
14959         TALLOC_CTX *_mem_save_keyword_0;
14960         uint32_t _ptr_mui_dll;
14961         TALLOC_CTX *_mem_save_mui_dll_0;
14962         uint32_t _ptr_display_name;
14963         TALLOC_CTX *_mem_save_display_name_0;
14964         if (ndr_flags & NDR_SCALARS) {
14965                 NDR_CHECK(ndr_pull_align(ndr, 4));
14966                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14967                 {
14968                         uint32_t _flags_save_string = ndr->flags;
14969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14970                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14971                         if (_ptr_form_name) {
14972                                 NDR_PULL_ALLOC(ndr, r->form_name);
14973                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14974                         } else {
14975                                 r->form_name = NULL;
14976                         }
14977                         ndr->flags = _flags_save_string;
14978                 }
14979                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14980                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14981                 {
14982                         uint32_t _flags_save_string = ndr->flags;
14983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14984                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
14985                         if (_ptr_keyword) {
14986                                 NDR_PULL_ALLOC(ndr, r->keyword);
14987                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
14988                         } else {
14989                                 r->keyword = NULL;
14990                         }
14991                         ndr->flags = _flags_save_string;
14992                 }
14993                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
14994                 {
14995                         uint32_t _flags_save_string = ndr->flags;
14996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14997                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
14998                         if (_ptr_mui_dll) {
14999                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15000                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15001                         } else {
15002                                 r->mui_dll = NULL;
15003                         }
15004                         ndr->flags = _flags_save_string;
15005                 }
15006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15007                 {
15008                         uint32_t _flags_save_string = ndr->flags;
15009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15010                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15011                         if (_ptr_display_name) {
15012                                 NDR_PULL_ALLOC(ndr, r->display_name);
15013                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15014                         } else {
15015                                 r->display_name = NULL;
15016                         }
15017                         ndr->flags = _flags_save_string;
15018                 }
15019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15020         }
15021         if (ndr_flags & NDR_BUFFERS) {
15022                 {
15023                         uint32_t _flags_save_string = ndr->flags;
15024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15025                         if (r->form_name) {
15026                                 uint32_t _relative_save_offset;
15027                                 _relative_save_offset = ndr->offset;
15028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15029                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15030                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15033                                 ndr->offset = _relative_save_offset;
15034                         }
15035                         ndr->flags = _flags_save_string;
15036                 }
15037                 {
15038                         uint32_t _flags_save_string = ndr->flags;
15039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15040                         if (r->keyword) {
15041                                 uint32_t _relative_save_offset;
15042                                 _relative_save_offset = ndr->offset;
15043                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15044                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15045                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15046                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15047                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15048                                 ndr->offset = _relative_save_offset;
15049                         }
15050                         ndr->flags = _flags_save_string;
15051                 }
15052                 {
15053                         uint32_t _flags_save_string = ndr->flags;
15054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15055                         if (r->mui_dll) {
15056                                 uint32_t _relative_save_offset;
15057                                 _relative_save_offset = ndr->offset;
15058                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15059                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15060                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15061                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15062                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15063                                 ndr->offset = _relative_save_offset;
15064                         }
15065                         ndr->flags = _flags_save_string;
15066                 }
15067                 {
15068                         uint32_t _flags_save_string = ndr->flags;
15069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15070                         if (r->display_name) {
15071                                 uint32_t _relative_save_offset;
15072                                 _relative_save_offset = ndr->offset;
15073                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15074                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15075                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15076                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15077                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15078                                 ndr->offset = _relative_save_offset;
15079                         }
15080                         ndr->flags = _flags_save_string;
15081                 }
15082         }
15083         return NDR_ERR_SUCCESS;
15084 }
15085
15086 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15087 {
15088         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15089         ndr->depth++;
15090         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15091         ndr_print_ptr(ndr, "form_name", r->form_name);
15092         ndr->depth++;
15093         if (r->form_name) {
15094                 ndr_print_string(ndr, "form_name", r->form_name);
15095         }
15096         ndr->depth--;
15097         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15098         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15099         ndr_print_ptr(ndr, "keyword", r->keyword);
15100         ndr->depth++;
15101         if (r->keyword) {
15102                 ndr_print_string(ndr, "keyword", r->keyword);
15103         }
15104         ndr->depth--;
15105         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15106         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15107         ndr->depth++;
15108         if (r->mui_dll) {
15109                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15110         }
15111         ndr->depth--;
15112         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15113         ndr_print_ptr(ndr, "display_name", r->display_name);
15114         ndr->depth++;
15115         if (r->display_name) {
15116                 ndr_print_string(ndr, "display_name", r->display_name);
15117         }
15118         ndr->depth--;
15119         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15120         ndr->depth--;
15121 }
15122
15123 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15124 {
15125         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15126         if (ndr_flags & NDR_SCALARS) {
15127                 int level = ndr_push_get_switch_value(ndr, r);
15128                 switch (level) {
15129                         case 1: {
15130                                 NDR_CHECK(ndr_push_align(ndr, 4));
15131                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15132                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15133                         break; }
15134
15135                         case 2: {
15136                                 NDR_CHECK(ndr_push_align(ndr, 4));
15137                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15138                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15139                         break; }
15140
15141                         default: {
15142                         break; }
15143
15144                 }
15145         }
15146         if (ndr_flags & NDR_BUFFERS) {
15147                 int level = ndr_push_get_switch_value(ndr, r);
15148                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15149                 switch (level) {
15150                         case 1:
15151                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15152                         break;
15153
15154                         case 2:
15155                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15156                         break;
15157
15158                         default:
15159                         break;
15160
15161                 }
15162         }
15163         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15164         return NDR_ERR_SUCCESS;
15165 }
15166
15167 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15168 {
15169         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15170         int level;
15171         level = ndr_pull_get_switch_value(ndr, r);
15172         if (ndr_flags & NDR_SCALARS) {
15173                 switch (level) {
15174                         case 1: {
15175                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15176                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15177                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15178                         break; }
15179
15180                         case 2: {
15181                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15182                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15183                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15184                         break; }
15185
15186                         default: {
15187                         break; }
15188
15189                 }
15190         }
15191         if (ndr_flags & NDR_BUFFERS) {
15192                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15193                 switch (level) {
15194                         case 1:
15195                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15196                         break;
15197
15198                         case 2:
15199                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15200                         break;
15201
15202                         default:
15203                         break;
15204
15205                 }
15206         }
15207         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15208         return NDR_ERR_SUCCESS;
15209 }
15210
15211 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15212 {
15213         int level;
15214         level = ndr_print_get_switch_value(ndr, r);
15215         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15216         switch (level) {
15217                 case 1:
15218                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15219                 break;
15220
15221                 case 2:
15222                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15223                 break;
15224
15225                 default:
15226                 break;
15227
15228         }
15229 }
15230
15231 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15232 {
15233         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15234 }
15235
15236 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15237 {
15238         if (ndr_flags & NDR_SCALARS) {
15239                 NDR_CHECK(ndr_push_align(ndr, 4));
15240                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15242                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15243                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15244         }
15245         if (ndr_flags & NDR_BUFFERS) {
15246                 if (r->form_name) {
15247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15251                 }
15252         }
15253         return NDR_ERR_SUCCESS;
15254 }
15255
15256 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15257 {
15258         uint32_t _ptr_form_name;
15259         TALLOC_CTX *_mem_save_form_name_0;
15260         if (ndr_flags & NDR_SCALARS) {
15261                 NDR_CHECK(ndr_pull_align(ndr, 4));
15262                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15264                 if (_ptr_form_name) {
15265                         NDR_PULL_ALLOC(ndr, r->form_name);
15266                 } else {
15267                         r->form_name = NULL;
15268                 }
15269                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15270                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15271         }
15272         if (ndr_flags & NDR_BUFFERS) {
15273                 if (r->form_name) {
15274                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15275                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15277                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15278                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15279                                 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));
15280                         }
15281                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15284                 }
15285         }
15286         return NDR_ERR_SUCCESS;
15287 }
15288
15289 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15290 {
15291         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15292         ndr->depth++;
15293         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15294         ndr_print_ptr(ndr, "form_name", r->form_name);
15295         ndr->depth++;
15296         if (r->form_name) {
15297                 ndr_print_string(ndr, "form_name", r->form_name);
15298         }
15299         ndr->depth--;
15300         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15301         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15302         ndr->depth--;
15303 }
15304
15305 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15306 {
15307         if (ndr_flags & NDR_SCALARS) {
15308                 NDR_CHECK(ndr_push_align(ndr, 4));
15309                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15311                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15312                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15314                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15319         }
15320         if (ndr_flags & NDR_BUFFERS) {
15321                 if (r->form_name) {
15322                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15325                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15326                 }
15327                 if (r->keyword) {
15328                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15329                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15330                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15331                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15332                 }
15333                 if (r->mui_dll) {
15334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15336                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15337                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15338                 }
15339                 if (r->display_name) {
15340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15343                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15344                 }
15345         }
15346         return NDR_ERR_SUCCESS;
15347 }
15348
15349 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15350 {
15351         uint32_t _ptr_form_name;
15352         TALLOC_CTX *_mem_save_form_name_0;
15353         uint32_t _ptr_keyword;
15354         TALLOC_CTX *_mem_save_keyword_0;
15355         uint32_t _ptr_mui_dll;
15356         TALLOC_CTX *_mem_save_mui_dll_0;
15357         uint32_t _ptr_display_name;
15358         TALLOC_CTX *_mem_save_display_name_0;
15359         if (ndr_flags & NDR_SCALARS) {
15360                 NDR_CHECK(ndr_pull_align(ndr, 4));
15361                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15363                 if (_ptr_form_name) {
15364                         NDR_PULL_ALLOC(ndr, r->form_name);
15365                 } else {
15366                         r->form_name = NULL;
15367                 }
15368                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15369                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15371                 if (_ptr_keyword) {
15372                         NDR_PULL_ALLOC(ndr, r->keyword);
15373                 } else {
15374                         r->keyword = NULL;
15375                 }
15376                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15378                 if (_ptr_mui_dll) {
15379                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15380                 } else {
15381                         r->mui_dll = NULL;
15382                 }
15383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15385                 if (_ptr_display_name) {
15386                         NDR_PULL_ALLOC(ndr, r->display_name);
15387                 } else {
15388                         r->display_name = NULL;
15389                 }
15390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15391         }
15392         if (ndr_flags & NDR_BUFFERS) {
15393                 if (r->form_name) {
15394                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15395                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15398                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15399                                 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));
15400                         }
15401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15404                 }
15405                 if (r->keyword) {
15406                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15407                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15408                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15409                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15410                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15411                                 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));
15412                         }
15413                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15414                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15416                 }
15417                 if (r->mui_dll) {
15418                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15419                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15422                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15423                                 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));
15424                         }
15425                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15428                 }
15429                 if (r->display_name) {
15430                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15431                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15433                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15434                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15435                                 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));
15436                         }
15437                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15438                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15440                 }
15441         }
15442         return NDR_ERR_SUCCESS;
15443 }
15444
15445 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15446 {
15447         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15448         ndr->depth++;
15449         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15450         ndr_print_ptr(ndr, "form_name", r->form_name);
15451         ndr->depth++;
15452         if (r->form_name) {
15453                 ndr_print_string(ndr, "form_name", r->form_name);
15454         }
15455         ndr->depth--;
15456         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15457         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15458         ndr_print_ptr(ndr, "keyword", r->keyword);
15459         ndr->depth++;
15460         if (r->keyword) {
15461                 ndr_print_string(ndr, "keyword", r->keyword);
15462         }
15463         ndr->depth--;
15464         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15465         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15466         ndr->depth++;
15467         if (r->mui_dll) {
15468                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15469         }
15470         ndr->depth--;
15471         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15472         ndr_print_ptr(ndr, "display_name", r->display_name);
15473         ndr->depth++;
15474         if (r->display_name) {
15475                 ndr_print_string(ndr, "display_name", r->display_name);
15476         }
15477         ndr->depth--;
15478         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15479         ndr->depth--;
15480 }
15481
15482 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15483 {
15484         if (ndr_flags & NDR_SCALARS) {
15485                 int level = ndr_push_get_switch_value(ndr, r);
15486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15487                 switch (level) {
15488                         case 1: {
15489                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15490                         break; }
15491
15492                         case 2: {
15493                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15494                         break; }
15495
15496                         default:
15497                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15498                 }
15499         }
15500         if (ndr_flags & NDR_BUFFERS) {
15501                 int level = ndr_push_get_switch_value(ndr, r);
15502                 switch (level) {
15503                         case 1:
15504                                 if (r->info1) {
15505                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15506                                 }
15507                         break;
15508
15509                         case 2:
15510                                 if (r->info2) {
15511                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15512                                 }
15513                         break;
15514
15515                         default:
15516                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15517                 }
15518         }
15519         return NDR_ERR_SUCCESS;
15520 }
15521
15522 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15523 {
15524         int level;
15525         uint32_t _level;
15526         TALLOC_CTX *_mem_save_info1_0;
15527         TALLOC_CTX *_mem_save_info2_0;
15528         level = ndr_pull_get_switch_value(ndr, r);
15529         if (ndr_flags & NDR_SCALARS) {
15530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15531                 if (_level != level) {
15532                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15533                 }
15534                 switch (level) {
15535                         case 1: {
15536                                 uint32_t _ptr_info1;
15537                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15538                                 if (_ptr_info1) {
15539                                         NDR_PULL_ALLOC(ndr, r->info1);
15540                                 } else {
15541                                         r->info1 = NULL;
15542                                 }
15543                         break; }
15544
15545                         case 2: {
15546                                 uint32_t _ptr_info2;
15547                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15548                                 if (_ptr_info2) {
15549                                         NDR_PULL_ALLOC(ndr, r->info2);
15550                                 } else {
15551                                         r->info2 = NULL;
15552                                 }
15553                         break; }
15554
15555                         default:
15556                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15557                 }
15558         }
15559         if (ndr_flags & NDR_BUFFERS) {
15560                 switch (level) {
15561                         case 1:
15562                                 if (r->info1) {
15563                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15564                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15565                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15566                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15567                                 }
15568                         break;
15569
15570                         case 2:
15571                                 if (r->info2) {
15572                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15573                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15574                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15575                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15576                                 }
15577                         break;
15578
15579                         default:
15580                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15581                 }
15582         }
15583         return NDR_ERR_SUCCESS;
15584 }
15585
15586 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15587 {
15588         int level;
15589         level = ndr_print_get_switch_value(ndr, r);
15590         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15591         switch (level) {
15592                 case 1:
15593                         ndr_print_ptr(ndr, "info1", r->info1);
15594                         ndr->depth++;
15595                         if (r->info1) {
15596                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15597                         }
15598                         ndr->depth--;
15599                 break;
15600
15601                 case 2:
15602                         ndr_print_ptr(ndr, "info2", r->info2);
15603                         ndr->depth++;
15604                         if (r->info2) {
15605                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15606                         }
15607                         ndr->depth--;
15608                 break;
15609
15610                 default:
15611                         ndr_print_bad_level(ndr, name, level);
15612         }
15613 }
15614
15615 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15616 {
15617         if (ndr_flags & NDR_SCALARS) {
15618                 NDR_CHECK(ndr_push_align(ndr, 4));
15619                 {
15620                         uint32_t _flags_save_string = ndr->flags;
15621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15622                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15623                         ndr->flags = _flags_save_string;
15624                 }
15625         }
15626         if (ndr_flags & NDR_BUFFERS) {
15627                 {
15628                         uint32_t _flags_save_string = ndr->flags;
15629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15630                         if (r->port_name) {
15631                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15632                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15633                         }
15634                         ndr->flags = _flags_save_string;
15635                 }
15636         }
15637         return NDR_ERR_SUCCESS;
15638 }
15639
15640 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15641 {
15642         uint32_t _ptr_port_name;
15643         TALLOC_CTX *_mem_save_port_name_0;
15644         if (ndr_flags & NDR_SCALARS) {
15645                 NDR_CHECK(ndr_pull_align(ndr, 4));
15646                 {
15647                         uint32_t _flags_save_string = ndr->flags;
15648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15649                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15650                         if (_ptr_port_name) {
15651                                 NDR_PULL_ALLOC(ndr, r->port_name);
15652                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15653                         } else {
15654                                 r->port_name = NULL;
15655                         }
15656                         ndr->flags = _flags_save_string;
15657                 }
15658         }
15659         if (ndr_flags & NDR_BUFFERS) {
15660                 {
15661                         uint32_t _flags_save_string = ndr->flags;
15662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15663                         if (r->port_name) {
15664                                 uint32_t _relative_save_offset;
15665                                 _relative_save_offset = ndr->offset;
15666                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15667                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15668                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15669                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15670                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15671                                 ndr->offset = _relative_save_offset;
15672                         }
15673                         ndr->flags = _flags_save_string;
15674                 }
15675         }
15676         return NDR_ERR_SUCCESS;
15677 }
15678
15679 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15680 {
15681         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15682         ndr->depth++;
15683         ndr_print_ptr(ndr, "port_name", r->port_name);
15684         ndr->depth++;
15685         if (r->port_name) {
15686                 ndr_print_string(ndr, "port_name", r->port_name);
15687         }
15688         ndr->depth--;
15689         ndr->depth--;
15690 }
15691
15692 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15693 {
15694         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15695         return NDR_ERR_SUCCESS;
15696 }
15697
15698 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15699 {
15700         uint32_t v;
15701         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15702         *r = v;
15703         return NDR_ERR_SUCCESS;
15704 }
15705
15706 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15707 {
15708         ndr_print_uint32(ndr, name, r);
15709         ndr->depth++;
15710         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15711         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15712         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15713         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15714         ndr->depth--;
15715 }
15716
15717 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15718 {
15719         if (ndr_flags & NDR_SCALARS) {
15720                 NDR_CHECK(ndr_push_align(ndr, 4));
15721                 {
15722                         uint32_t _flags_save_string = ndr->flags;
15723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15724                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15725                         ndr->flags = _flags_save_string;
15726                 }
15727                 {
15728                         uint32_t _flags_save_string = ndr->flags;
15729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15731                         ndr->flags = _flags_save_string;
15732                 }
15733                 {
15734                         uint32_t _flags_save_string = ndr->flags;
15735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15736                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15737                         ndr->flags = _flags_save_string;
15738                 }
15739                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15741         }
15742         if (ndr_flags & NDR_BUFFERS) {
15743                 {
15744                         uint32_t _flags_save_string = ndr->flags;
15745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15746                         if (r->port_name) {
15747                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15748                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15749                         }
15750                         ndr->flags = _flags_save_string;
15751                 }
15752                 {
15753                         uint32_t _flags_save_string = ndr->flags;
15754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15755                         if (r->monitor_name) {
15756                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15757                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15758                         }
15759                         ndr->flags = _flags_save_string;
15760                 }
15761                 {
15762                         uint32_t _flags_save_string = ndr->flags;
15763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15764                         if (r->description) {
15765                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15766                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15767                         }
15768                         ndr->flags = _flags_save_string;
15769                 }
15770         }
15771         return NDR_ERR_SUCCESS;
15772 }
15773
15774 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15775 {
15776         uint32_t _ptr_port_name;
15777         TALLOC_CTX *_mem_save_port_name_0;
15778         uint32_t _ptr_monitor_name;
15779         TALLOC_CTX *_mem_save_monitor_name_0;
15780         uint32_t _ptr_description;
15781         TALLOC_CTX *_mem_save_description_0;
15782         if (ndr_flags & NDR_SCALARS) {
15783                 NDR_CHECK(ndr_pull_align(ndr, 4));
15784                 {
15785                         uint32_t _flags_save_string = ndr->flags;
15786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15788                         if (_ptr_port_name) {
15789                                 NDR_PULL_ALLOC(ndr, r->port_name);
15790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15791                         } else {
15792                                 r->port_name = NULL;
15793                         }
15794                         ndr->flags = _flags_save_string;
15795                 }
15796                 {
15797                         uint32_t _flags_save_string = ndr->flags;
15798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15800                         if (_ptr_monitor_name) {
15801                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15803                         } else {
15804                                 r->monitor_name = NULL;
15805                         }
15806                         ndr->flags = _flags_save_string;
15807                 }
15808                 {
15809                         uint32_t _flags_save_string = ndr->flags;
15810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15812                         if (_ptr_description) {
15813                                 NDR_PULL_ALLOC(ndr, r->description);
15814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15815                         } else {
15816                                 r->description = NULL;
15817                         }
15818                         ndr->flags = _flags_save_string;
15819                 }
15820                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15822         }
15823         if (ndr_flags & NDR_BUFFERS) {
15824                 {
15825                         uint32_t _flags_save_string = ndr->flags;
15826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15827                         if (r->port_name) {
15828                                 uint32_t _relative_save_offset;
15829                                 _relative_save_offset = ndr->offset;
15830                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15831                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15832                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15833                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15834                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15835                                 ndr->offset = _relative_save_offset;
15836                         }
15837                         ndr->flags = _flags_save_string;
15838                 }
15839                 {
15840                         uint32_t _flags_save_string = ndr->flags;
15841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15842                         if (r->monitor_name) {
15843                                 uint32_t _relative_save_offset;
15844                                 _relative_save_offset = ndr->offset;
15845                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15846                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15847                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15848                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15849                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15850                                 ndr->offset = _relative_save_offset;
15851                         }
15852                         ndr->flags = _flags_save_string;
15853                 }
15854                 {
15855                         uint32_t _flags_save_string = ndr->flags;
15856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15857                         if (r->description) {
15858                                 uint32_t _relative_save_offset;
15859                                 _relative_save_offset = ndr->offset;
15860                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15861                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15862                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15863                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15864                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15865                                 ndr->offset = _relative_save_offset;
15866                         }
15867                         ndr->flags = _flags_save_string;
15868                 }
15869         }
15870         return NDR_ERR_SUCCESS;
15871 }
15872
15873 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15874 {
15875         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15876         ndr->depth++;
15877         ndr_print_ptr(ndr, "port_name", r->port_name);
15878         ndr->depth++;
15879         if (r->port_name) {
15880                 ndr_print_string(ndr, "port_name", r->port_name);
15881         }
15882         ndr->depth--;
15883         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15884         ndr->depth++;
15885         if (r->monitor_name) {
15886                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15887         }
15888         ndr->depth--;
15889         ndr_print_ptr(ndr, "description", r->description);
15890         ndr->depth++;
15891         if (r->description) {
15892                 ndr_print_string(ndr, "description", r->description);
15893         }
15894         ndr->depth--;
15895         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15896         ndr_print_uint32(ndr, "reserved", r->reserved);
15897         ndr->depth--;
15898 }
15899
15900 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15901 {
15902         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15903         return NDR_ERR_SUCCESS;
15904 }
15905
15906 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
15907 {
15908         uint32_t v;
15909         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15910         *r = v;
15911         return NDR_ERR_SUCCESS;
15912 }
15913
15914 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
15915 {
15916         const char *val = NULL;
15917
15918         switch (r) {
15919                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
15920                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
15921                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
15922                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
15923                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
15924                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
15925                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
15926                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
15927                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
15928                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
15929                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
15930                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
15931                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
15932         }
15933         ndr_print_enum(ndr, name, "ENUM", val, r);
15934 }
15935
15936 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
15937 {
15938         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15939         return NDR_ERR_SUCCESS;
15940 }
15941
15942 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
15943 {
15944         uint32_t v;
15945         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15946         *r = v;
15947         return NDR_ERR_SUCCESS;
15948 }
15949
15950 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
15951 {
15952         const char *val = NULL;
15953
15954         switch (r) {
15955                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
15956                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
15957                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
15958         }
15959         ndr_print_enum(ndr, name, "ENUM", val, r);
15960 }
15961
15962 static enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
15963 {
15964         if (ndr_flags & NDR_SCALARS) {
15965                 NDR_CHECK(ndr_push_align(ndr, 4));
15966                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
15967                 {
15968                         uint32_t _flags_save_string = ndr->flags;
15969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15970                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
15971                         ndr->flags = _flags_save_string;
15972                 }
15973                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
15974         }
15975         if (ndr_flags & NDR_BUFFERS) {
15976                 {
15977                         uint32_t _flags_save_string = ndr->flags;
15978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15979                         if (r->status_string) {
15980                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
15981                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
15982                         }
15983                         ndr->flags = _flags_save_string;
15984                 }
15985         }
15986         return NDR_ERR_SUCCESS;
15987 }
15988
15989 static enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
15990 {
15991         uint32_t _ptr_status_string;
15992         TALLOC_CTX *_mem_save_status_string_0;
15993         if (ndr_flags & NDR_SCALARS) {
15994                 NDR_CHECK(ndr_pull_align(ndr, 4));
15995                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
15996                 {
15997                         uint32_t _flags_save_string = ndr->flags;
15998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15999                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16000                         if (_ptr_status_string) {
16001                                 NDR_PULL_ALLOC(ndr, r->status_string);
16002                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16003                         } else {
16004                                 r->status_string = NULL;
16005                         }
16006                         ndr->flags = _flags_save_string;
16007                 }
16008                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16009         }
16010         if (ndr_flags & NDR_BUFFERS) {
16011                 {
16012                         uint32_t _flags_save_string = ndr->flags;
16013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16014                         if (r->status_string) {
16015                                 uint32_t _relative_save_offset;
16016                                 _relative_save_offset = ndr->offset;
16017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16018                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16019                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16020                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16022                                 ndr->offset = _relative_save_offset;
16023                         }
16024                         ndr->flags = _flags_save_string;
16025                 }
16026         }
16027         return NDR_ERR_SUCCESS;
16028 }
16029
16030 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16031 {
16032         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16033         ndr->depth++;
16034         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16035         ndr_print_ptr(ndr, "status_string", r->status_string);
16036         ndr->depth++;
16037         if (r->status_string) {
16038                 ndr_print_string(ndr, "status_string", r->status_string);
16039         }
16040         ndr->depth--;
16041         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16042         ndr->depth--;
16043 }
16044
16045 static enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16046 {
16047         if (ndr_flags & NDR_SCALARS) {
16048                 NDR_CHECK(ndr_push_align(ndr, 4));
16049                 {
16050                         uint32_t _flags_save_string = ndr->flags;
16051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16052                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16053                         ndr->flags = _flags_save_string;
16054                 }
16055                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16056         }
16057         if (ndr_flags & NDR_BUFFERS) {
16058                 {
16059                         uint32_t _flags_save_string = ndr->flags;
16060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16061                         if (r->port_name) {
16062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16064                         }
16065                         ndr->flags = _flags_save_string;
16066                 }
16067         }
16068         return NDR_ERR_SUCCESS;
16069 }
16070
16071 static enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16072 {
16073         uint32_t _ptr_port_name;
16074         TALLOC_CTX *_mem_save_port_name_0;
16075         if (ndr_flags & NDR_SCALARS) {
16076                 NDR_CHECK(ndr_pull_align(ndr, 4));
16077                 {
16078                         uint32_t _flags_save_string = ndr->flags;
16079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16080                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16081                         if (_ptr_port_name) {
16082                                 NDR_PULL_ALLOC(ndr, r->port_name);
16083                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16084                         } else {
16085                                 r->port_name = NULL;
16086                         }
16087                         ndr->flags = _flags_save_string;
16088                 }
16089                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16090         }
16091         if (ndr_flags & NDR_BUFFERS) {
16092                 {
16093                         uint32_t _flags_save_string = ndr->flags;
16094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16095                         if (r->port_name) {
16096                                 uint32_t _relative_save_offset;
16097                                 _relative_save_offset = ndr->offset;
16098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16099                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16100                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16103                                 ndr->offset = _relative_save_offset;
16104                         }
16105                         ndr->flags = _flags_save_string;
16106                 }
16107         }
16108         return NDR_ERR_SUCCESS;
16109 }
16110
16111 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16112 {
16113         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16114         ndr->depth++;
16115         ndr_print_ptr(ndr, "port_name", r->port_name);
16116         ndr->depth++;
16117         if (r->port_name) {
16118                 ndr_print_string(ndr, "port_name", r->port_name);
16119         }
16120         ndr->depth--;
16121         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16122         ndr->depth--;
16123 }
16124
16125 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16126 {
16127         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16128         if (ndr_flags & NDR_SCALARS) {
16129                 int level = ndr_push_get_switch_value(ndr, r);
16130                 switch (level) {
16131                         case 1: {
16132                                 NDR_CHECK(ndr_push_align(ndr, 4));
16133                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16134                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16135                         break; }
16136
16137                         case 2: {
16138                                 NDR_CHECK(ndr_push_align(ndr, 4));
16139                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16140                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16141                         break; }
16142
16143                         case 3: {
16144                                 NDR_CHECK(ndr_push_align(ndr, 4));
16145                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16146                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16147                         break; }
16148
16149                         case 0xff: {
16150                                 NDR_CHECK(ndr_push_align(ndr, 4));
16151                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16152                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16153                         break; }
16154
16155                         default: {
16156                         break; }
16157
16158                 }
16159         }
16160         if (ndr_flags & NDR_BUFFERS) {
16161                 int level = ndr_push_get_switch_value(ndr, r);
16162                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16163                 switch (level) {
16164                         case 1:
16165                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16166                         break;
16167
16168                         case 2:
16169                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16170                         break;
16171
16172                         case 3:
16173                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16174                         break;
16175
16176                         case 0xff:
16177                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16178                         break;
16179
16180                         default:
16181                         break;
16182
16183                 }
16184         }
16185         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16186         return NDR_ERR_SUCCESS;
16187 }
16188
16189 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16190 {
16191         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16192         int level;
16193         level = ndr_pull_get_switch_value(ndr, r);
16194         if (ndr_flags & NDR_SCALARS) {
16195                 switch (level) {
16196                         case 1: {
16197                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16198                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16199                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16200                         break; }
16201
16202                         case 2: {
16203                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16204                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16205                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16206                         break; }
16207
16208                         case 3: {
16209                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16210                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16211                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16212                         break; }
16213
16214                         case 0xff: {
16215                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16216                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16217                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16218                         break; }
16219
16220                         default: {
16221                         break; }
16222
16223                 }
16224         }
16225         if (ndr_flags & NDR_BUFFERS) {
16226                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16227                 switch (level) {
16228                         case 1:
16229                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16230                         break;
16231
16232                         case 2:
16233                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16234                         break;
16235
16236                         case 3:
16237                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16238                         break;
16239
16240                         case 0xff:
16241                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16242                         break;
16243
16244                         default:
16245                         break;
16246
16247                 }
16248         }
16249         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16250         return NDR_ERR_SUCCESS;
16251 }
16252
16253 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16254 {
16255         int level;
16256         level = ndr_print_get_switch_value(ndr, r);
16257         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16258         switch (level) {
16259                 case 1:
16260                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16261                 break;
16262
16263                 case 2:
16264                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16265                 break;
16266
16267                 case 3:
16268                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16269                 break;
16270
16271                 case 0xff:
16272                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16273                 break;
16274
16275                 default:
16276                 break;
16277
16278         }
16279 }
16280
16281 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16282 {
16283         if (ndr_flags & NDR_SCALARS) {
16284                 NDR_CHECK(ndr_push_align(ndr, 4));
16285                 {
16286                         uint32_t _flags_save_string = ndr->flags;
16287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16289                         ndr->flags = _flags_save_string;
16290                 }
16291         }
16292         if (ndr_flags & NDR_BUFFERS) {
16293                 {
16294                         uint32_t _flags_save_string = ndr->flags;
16295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16296                         if (r->monitor_name) {
16297                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16298                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16299                         }
16300                         ndr->flags = _flags_save_string;
16301                 }
16302         }
16303         return NDR_ERR_SUCCESS;
16304 }
16305
16306 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16307 {
16308         uint32_t _ptr_monitor_name;
16309         TALLOC_CTX *_mem_save_monitor_name_0;
16310         if (ndr_flags & NDR_SCALARS) {
16311                 NDR_CHECK(ndr_pull_align(ndr, 4));
16312                 {
16313                         uint32_t _flags_save_string = ndr->flags;
16314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16316                         if (_ptr_monitor_name) {
16317                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16319                         } else {
16320                                 r->monitor_name = NULL;
16321                         }
16322                         ndr->flags = _flags_save_string;
16323                 }
16324         }
16325         if (ndr_flags & NDR_BUFFERS) {
16326                 {
16327                         uint32_t _flags_save_string = ndr->flags;
16328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16329                         if (r->monitor_name) {
16330                                 uint32_t _relative_save_offset;
16331                                 _relative_save_offset = ndr->offset;
16332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16333                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16334                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16337                                 ndr->offset = _relative_save_offset;
16338                         }
16339                         ndr->flags = _flags_save_string;
16340                 }
16341         }
16342         return NDR_ERR_SUCCESS;
16343 }
16344
16345 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16346 {
16347         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16348         ndr->depth++;
16349         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16350         ndr->depth++;
16351         if (r->monitor_name) {
16352                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16353         }
16354         ndr->depth--;
16355         ndr->depth--;
16356 }
16357
16358 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16359 {
16360         if (ndr_flags & NDR_SCALARS) {
16361                 NDR_CHECK(ndr_push_align(ndr, 4));
16362                 {
16363                         uint32_t _flags_save_string = ndr->flags;
16364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16365                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16366                         ndr->flags = _flags_save_string;
16367                 }
16368                 {
16369                         uint32_t _flags_save_string = ndr->flags;
16370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16371                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16372                         ndr->flags = _flags_save_string;
16373                 }
16374                 {
16375                         uint32_t _flags_save_string = ndr->flags;
16376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16378                         ndr->flags = _flags_save_string;
16379                 }
16380         }
16381         if (ndr_flags & NDR_BUFFERS) {
16382                 {
16383                         uint32_t _flags_save_string = ndr->flags;
16384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16385                         if (r->monitor_name) {
16386                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16387                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16388                         }
16389                         ndr->flags = _flags_save_string;
16390                 }
16391                 {
16392                         uint32_t _flags_save_string = ndr->flags;
16393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16394                         if (r->environment) {
16395                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16396                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16397                         }
16398                         ndr->flags = _flags_save_string;
16399                 }
16400                 {
16401                         uint32_t _flags_save_string = ndr->flags;
16402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16403                         if (r->dll_name) {
16404                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16405                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16406                         }
16407                         ndr->flags = _flags_save_string;
16408                 }
16409         }
16410         return NDR_ERR_SUCCESS;
16411 }
16412
16413 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16414 {
16415         uint32_t _ptr_monitor_name;
16416         TALLOC_CTX *_mem_save_monitor_name_0;
16417         uint32_t _ptr_environment;
16418         TALLOC_CTX *_mem_save_environment_0;
16419         uint32_t _ptr_dll_name;
16420         TALLOC_CTX *_mem_save_dll_name_0;
16421         if (ndr_flags & NDR_SCALARS) {
16422                 NDR_CHECK(ndr_pull_align(ndr, 4));
16423                 {
16424                         uint32_t _flags_save_string = ndr->flags;
16425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16426                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16427                         if (_ptr_monitor_name) {
16428                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16429                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16430                         } else {
16431                                 r->monitor_name = NULL;
16432                         }
16433                         ndr->flags = _flags_save_string;
16434                 }
16435                 {
16436                         uint32_t _flags_save_string = ndr->flags;
16437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16438                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16439                         if (_ptr_environment) {
16440                                 NDR_PULL_ALLOC(ndr, r->environment);
16441                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16442                         } else {
16443                                 r->environment = NULL;
16444                         }
16445                         ndr->flags = _flags_save_string;
16446                 }
16447                 {
16448                         uint32_t _flags_save_string = ndr->flags;
16449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16450                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16451                         if (_ptr_dll_name) {
16452                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16453                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16454                         } else {
16455                                 r->dll_name = NULL;
16456                         }
16457                         ndr->flags = _flags_save_string;
16458                 }
16459         }
16460         if (ndr_flags & NDR_BUFFERS) {
16461                 {
16462                         uint32_t _flags_save_string = ndr->flags;
16463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16464                         if (r->monitor_name) {
16465                                 uint32_t _relative_save_offset;
16466                                 _relative_save_offset = ndr->offset;
16467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16468                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16469                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16472                                 ndr->offset = _relative_save_offset;
16473                         }
16474                         ndr->flags = _flags_save_string;
16475                 }
16476                 {
16477                         uint32_t _flags_save_string = ndr->flags;
16478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16479                         if (r->environment) {
16480                                 uint32_t _relative_save_offset;
16481                                 _relative_save_offset = ndr->offset;
16482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16483                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16484                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16487                                 ndr->offset = _relative_save_offset;
16488                         }
16489                         ndr->flags = _flags_save_string;
16490                 }
16491                 {
16492                         uint32_t _flags_save_string = ndr->flags;
16493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16494                         if (r->dll_name) {
16495                                 uint32_t _relative_save_offset;
16496                                 _relative_save_offset = ndr->offset;
16497                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16498                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16499                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16500                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16501                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16502                                 ndr->offset = _relative_save_offset;
16503                         }
16504                         ndr->flags = _flags_save_string;
16505                 }
16506         }
16507         return NDR_ERR_SUCCESS;
16508 }
16509
16510 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16511 {
16512         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16513         ndr->depth++;
16514         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16515         ndr->depth++;
16516         if (r->monitor_name) {
16517                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16518         }
16519         ndr->depth--;
16520         ndr_print_ptr(ndr, "environment", r->environment);
16521         ndr->depth++;
16522         if (r->environment) {
16523                 ndr_print_string(ndr, "environment", r->environment);
16524         }
16525         ndr->depth--;
16526         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16527         ndr->depth++;
16528         if (r->dll_name) {
16529                 ndr_print_string(ndr, "dll_name", r->dll_name);
16530         }
16531         ndr->depth--;
16532         ndr->depth--;
16533 }
16534
16535 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16536 {
16537         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16538         if (ndr_flags & NDR_SCALARS) {
16539                 int level = ndr_push_get_switch_value(ndr, r);
16540                 switch (level) {
16541                         case 1: {
16542                                 NDR_CHECK(ndr_push_align(ndr, 4));
16543                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16544                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16545                         break; }
16546
16547                         case 2: {
16548                                 NDR_CHECK(ndr_push_align(ndr, 4));
16549                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16550                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16551                         break; }
16552
16553                         default: {
16554                         break; }
16555
16556                 }
16557         }
16558         if (ndr_flags & NDR_BUFFERS) {
16559                 int level = ndr_push_get_switch_value(ndr, r);
16560                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16561                 switch (level) {
16562                         case 1:
16563                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16564                         break;
16565
16566                         case 2:
16567                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16568                         break;
16569
16570                         default:
16571                         break;
16572
16573                 }
16574         }
16575         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16576         return NDR_ERR_SUCCESS;
16577 }
16578
16579 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16580 {
16581         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16582         int level;
16583         level = ndr_pull_get_switch_value(ndr, r);
16584         if (ndr_flags & NDR_SCALARS) {
16585                 switch (level) {
16586                         case 1: {
16587                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16588                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16589                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16590                         break; }
16591
16592                         case 2: {
16593                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16594                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16595                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16596                         break; }
16597
16598                         default: {
16599                         break; }
16600
16601                 }
16602         }
16603         if (ndr_flags & NDR_BUFFERS) {
16604                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16605                 switch (level) {
16606                         case 1:
16607                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16608                         break;
16609
16610                         case 2:
16611                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16612                         break;
16613
16614                         default:
16615                         break;
16616
16617                 }
16618         }
16619         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16620         return NDR_ERR_SUCCESS;
16621 }
16622
16623 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16624 {
16625         int level;
16626         level = ndr_print_get_switch_value(ndr, r);
16627         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16628         switch (level) {
16629                 case 1:
16630                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16631                 break;
16632
16633                 case 2:
16634                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16635                 break;
16636
16637                 default:
16638                 break;
16639
16640         }
16641 }
16642
16643 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16644 {
16645         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16646         return NDR_ERR_SUCCESS;
16647 }
16648
16649 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16650 {
16651         uint32_t v;
16652         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16653         *r = v;
16654         return NDR_ERR_SUCCESS;
16655 }
16656
16657 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16658 {
16659         ndr_print_uint32(ndr, name, r);
16660         ndr->depth++;
16661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16678         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16679         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16680         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16681         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16682         ndr->depth--;
16683 }
16684
16685 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16686 {
16687         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16688         return NDR_ERR_SUCCESS;
16689 }
16690
16691 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16692 {
16693         uint16_t v;
16694         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16695         *r = v;
16696         return NDR_ERR_SUCCESS;
16697 }
16698
16699 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16700 {
16701         const char *val = NULL;
16702
16703         switch (r) {
16704                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16705                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16706                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16707                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16708                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16709                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16710                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16711                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16712                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16713                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16714                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16715                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16716                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16717                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
16718                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
16719                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
16720                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
16721                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
16722                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
16723                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
16724                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
16725                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
16726                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
16727                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
16728                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
16729                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
16730         }
16731         ndr_print_enum(ndr, name, "ENUM", val, r);
16732 }
16733
16734 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
16735 {
16736         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16737         return NDR_ERR_SUCCESS;
16738 }
16739
16740 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
16741 {
16742         uint16_t v;
16743         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16744         *r = v;
16745         return NDR_ERR_SUCCESS;
16746 }
16747
16748 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
16749 {
16750         const char *val = NULL;
16751
16752         switch (r) {
16753                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
16754                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
16755         }
16756         ndr_print_enum(ndr, name, "ENUM", val, r);
16757 }
16758
16759 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
16760 {
16761         uint32_t cntr_fields_1;
16762         if (ndr_flags & NDR_SCALARS) {
16763                 NDR_CHECK(ndr_push_align(ndr, 4));
16764                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
16765                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
16766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
16767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
16768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
16770         }
16771         if (ndr_flags & NDR_BUFFERS) {
16772                 if (r->fields) {
16773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16774                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
16775                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
16776                         }
16777                 }
16778         }
16779         return NDR_ERR_SUCCESS;
16780 }
16781
16782 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
16783 {
16784         uint32_t _ptr_fields;
16785         uint32_t cntr_fields_1;
16786         TALLOC_CTX *_mem_save_fields_0;
16787         TALLOC_CTX *_mem_save_fields_1;
16788         if (ndr_flags & NDR_SCALARS) {
16789                 NDR_CHECK(ndr_pull_align(ndr, 4));
16790                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
16791                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
16792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
16793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
16794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
16795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
16796                 if (_ptr_fields) {
16797                         NDR_PULL_ALLOC(ndr, r->fields);
16798                 } else {
16799                         r->fields = NULL;
16800                 }
16801         }
16802         if (ndr_flags & NDR_BUFFERS) {
16803                 if (r->fields) {
16804                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
16805                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
16806                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
16807                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
16808                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
16809                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
16810                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
16811                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
16812                         }
16813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
16814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
16815                 }
16816                 if (r->fields) {
16817                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
16818                 }
16819         }
16820         return NDR_ERR_SUCCESS;
16821 }
16822
16823 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
16824 {
16825         uint32_t cntr_fields_1;
16826         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
16827         ndr->depth++;
16828         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
16829         ndr_print_uint16(ndr, "u1", r->u1);
16830         ndr_print_uint32(ndr, "u2", r->u2);
16831         ndr_print_uint32(ndr, "u3", r->u3);
16832         ndr_print_uint32(ndr, "count", r->count);
16833         ndr_print_ptr(ndr, "fields", r->fields);
16834         ndr->depth++;
16835         if (r->fields) {
16836                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
16837                 ndr->depth++;
16838                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
16839                         char *idx_1=NULL;
16840                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
16841                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
16842                                 free(idx_1);
16843                         }
16844                 }
16845                 ndr->depth--;
16846         }
16847         ndr->depth--;
16848         ndr->depth--;
16849 }
16850
16851 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16852 {
16853         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16854         return NDR_ERR_SUCCESS;
16855 }
16856
16857 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16858 {
16859         uint32_t v;
16860         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16861         *r = v;
16862         return NDR_ERR_SUCCESS;
16863 }
16864
16865 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16866 {
16867         ndr_print_uint32(ndr, name, r);
16868         ndr->depth++;
16869         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
16870         ndr->depth--;
16871 }
16872
16873 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
16874 {
16875         uint32_t cntr_types_1;
16876         if (ndr_flags & NDR_SCALARS) {
16877                 NDR_CHECK(ndr_push_align(ndr, 4));
16878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
16879                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
16880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
16882         }
16883         if (ndr_flags & NDR_BUFFERS) {
16884                 if (r->types) {
16885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
16886                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
16887                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
16888                         }
16889                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
16890                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
16891                         }
16892                 }
16893         }
16894         return NDR_ERR_SUCCESS;
16895 }
16896
16897 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
16898 {
16899         uint32_t _ptr_types;
16900         uint32_t cntr_types_1;
16901         TALLOC_CTX *_mem_save_types_0;
16902         TALLOC_CTX *_mem_save_types_1;
16903         if (ndr_flags & NDR_SCALARS) {
16904                 NDR_CHECK(ndr_pull_align(ndr, 4));
16905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
16906                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
16907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
16908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
16909                 if (_ptr_types) {
16910                         NDR_PULL_ALLOC(ndr, r->types);
16911                 } else {
16912                         r->types = NULL;
16913                 }
16914         }
16915         if (ndr_flags & NDR_BUFFERS) {
16916                 if (r->types) {
16917                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
16918                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
16919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
16920                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
16921                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
16922                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
16923                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
16924                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
16925                         }
16926                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
16927                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
16928                         }
16929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
16930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
16931                 }
16932                 if (r->types) {
16933                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
16934                 }
16935         }
16936         return NDR_ERR_SUCCESS;
16937 }
16938
16939 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
16940 {
16941         uint32_t cntr_types_1;
16942         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
16943         ndr->depth++;
16944         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
16945         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
16946         ndr_print_uint32(ndr, "count", r->count);
16947         ndr_print_ptr(ndr, "types", r->types);
16948         ndr->depth++;
16949         if (r->types) {
16950                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
16951                 ndr->depth++;
16952                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
16953                         char *idx_1=NULL;
16954                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
16955                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
16956                                 free(idx_1);
16957                         }
16958                 }
16959                 ndr->depth--;
16960         }
16961         ndr->depth--;
16962         ndr->depth--;
16963 }
16964
16965 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
16966 {
16967         if (ndr_flags & NDR_SCALARS) {
16968                 NDR_CHECK(ndr_push_align(ndr, 4));
16969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
16970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
16971         }
16972         if (ndr_flags & NDR_BUFFERS) {
16973                 if (r->string) {
16974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
16975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
16976                 }
16977         }
16978         return NDR_ERR_SUCCESS;
16979 }
16980
16981 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
16982 {
16983         uint32_t _ptr_string;
16984         TALLOC_CTX *_mem_save_string_0;
16985         if (ndr_flags & NDR_SCALARS) {
16986                 NDR_CHECK(ndr_pull_align(ndr, 4));
16987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
16988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
16989                 if (_ptr_string) {
16990                         NDR_PULL_ALLOC(ndr, r->string);
16991                 } else {
16992                         r->string = NULL;
16993                 }
16994         }
16995         if (ndr_flags & NDR_BUFFERS) {
16996                 if (r->string) {
16997                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16998                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
16999                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17002                 }
17003                 if (r->string) {
17004                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17005                 }
17006         }
17007         return NDR_ERR_SUCCESS;
17008 }
17009
17010 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17011 {
17012         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17013         ndr->depth++;
17014         ndr_print_uint32(ndr, "size", r->size);
17015         ndr_print_ptr(ndr, "string", r->string);
17016         ndr->depth++;
17017         if (r->string) {
17018                 ndr_print_string(ndr, "string", r->string);
17019         }
17020         ndr->depth--;
17021         ndr->depth--;
17022 }
17023
17024 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17025 {
17026         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17027         return NDR_ERR_SUCCESS;
17028 }
17029
17030 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17031 {
17032         uint32_t v;
17033         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17034         *r = v;
17035         return NDR_ERR_SUCCESS;
17036 }
17037
17038 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17039 {
17040         const char *val = NULL;
17041
17042         switch (r) {
17043                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17044                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17045                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17046                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17047                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17048         }
17049         ndr_print_enum(ndr, name, "ENUM", val, r);
17050 }
17051
17052 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17053 {
17054         if (ndr_flags & NDR_SCALARS) {
17055                 int level = ndr_push_get_switch_value(ndr, r);
17056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17057                 switch (level) {
17058                         case 1: {
17059                                 uint32_t cntr_integer_0;
17060                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17061                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17062                                 }
17063                         break; }
17064
17065                         case 2: {
17066                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17067                         break; }
17068
17069                         case 3: {
17070                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17071                         break; }
17072
17073                         case 4: {
17074                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17075                         break; }
17076
17077                         case 5: {
17078                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17079                         break; }
17080
17081                         default:
17082                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17083                 }
17084         }
17085         if (ndr_flags & NDR_BUFFERS) {
17086                 int level = ndr_push_get_switch_value(ndr, r);
17087                 switch (level) {
17088                         case 1:
17089                         break;
17090
17091                         case 2:
17092                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17093                         break;
17094
17095                         case 3:
17096                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17097                         break;
17098
17099                         case 4:
17100                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17101                         break;
17102
17103                         case 5:
17104                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17105                         break;
17106
17107                         default:
17108                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17109                 }
17110         }
17111         return NDR_ERR_SUCCESS;
17112 }
17113
17114 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17115 {
17116         int level;
17117         uint32_t _level;
17118         level = ndr_pull_get_switch_value(ndr, r);
17119         if (ndr_flags & NDR_SCALARS) {
17120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17121                 if (_level != level) {
17122                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17123                 }
17124                 switch (level) {
17125                         case 1: {
17126                                 uint32_t cntr_integer_0;
17127                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17128                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17129                                 }
17130                         break; }
17131
17132                         case 2: {
17133                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17134                         break; }
17135
17136                         case 3: {
17137                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17138                         break; }
17139
17140                         case 4: {
17141                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17142                         break; }
17143
17144                         case 5: {
17145                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17146                         break; }
17147
17148                         default:
17149                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17150                 }
17151         }
17152         if (ndr_flags & NDR_BUFFERS) {
17153                 switch (level) {
17154                         case 1:
17155                         break;
17156
17157                         case 2:
17158                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17159                         break;
17160
17161                         case 3:
17162                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17163                         break;
17164
17165                         case 4:
17166                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17167                         break;
17168
17169                         case 5:
17170                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17171                         break;
17172
17173                         default:
17174                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17175                 }
17176         }
17177         return NDR_ERR_SUCCESS;
17178 }
17179
17180 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17181 {
17182         int level;
17183         uint32_t cntr_integer_0;
17184         level = ndr_print_get_switch_value(ndr, r);
17185         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17186         switch (level) {
17187                 case 1:
17188                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17189                         ndr->depth++;
17190                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17191                                 char *idx_0=NULL;
17192                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17193                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17194                                         free(idx_0);
17195                                 }
17196                         }
17197                         ndr->depth--;
17198                 break;
17199
17200                 case 2:
17201                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17202                 break;
17203
17204                 case 3:
17205                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17206                 break;
17207
17208                 case 4:
17209                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17210                 break;
17211
17212                 case 5:
17213                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17214                 break;
17215
17216                 default:
17217                         ndr_print_bad_level(ndr, name, level);
17218         }
17219 }
17220
17221 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17222 {
17223         if (ndr_flags & NDR_SCALARS) {
17224                 NDR_CHECK(ndr_push_align(ndr, 4));
17225                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17226                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17227                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17229                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17230                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17231         }
17232         if (ndr_flags & NDR_BUFFERS) {
17233                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17234         }
17235         return NDR_ERR_SUCCESS;
17236 }
17237
17238 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17239 {
17240         if (ndr_flags & NDR_SCALARS) {
17241                 NDR_CHECK(ndr_pull_align(ndr, 4));
17242                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17243                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17244                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17246                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17247                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17248         }
17249         if (ndr_flags & NDR_BUFFERS) {
17250                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17251         }
17252         return NDR_ERR_SUCCESS;
17253 }
17254
17255 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17256 {
17257         ndr_print_struct(ndr, name, "spoolss_Notify");
17258         ndr->depth++;
17259         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17260         ndr_print_spoolss_Field(ndr, "field", r->field);
17261         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17262         ndr_print_uint32(ndr, "job_id", r->job_id);
17263         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17264         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17265         ndr->depth--;
17266 }
17267
17268 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17269 {
17270         uint32_t cntr_notifies_0;
17271         if (ndr_flags & NDR_SCALARS) {
17272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17273                 NDR_CHECK(ndr_push_align(ndr, 4));
17274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17277                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17278                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17279                 }
17280         }
17281         if (ndr_flags & NDR_BUFFERS) {
17282                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17283                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17284                 }
17285         }
17286         return NDR_ERR_SUCCESS;
17287 }
17288
17289 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17290 {
17291         uint32_t cntr_notifies_0;
17292         TALLOC_CTX *_mem_save_notifies_0;
17293         if (ndr_flags & NDR_SCALARS) {
17294                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17295                 NDR_CHECK(ndr_pull_align(ndr, 4));
17296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17299                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17300                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17301                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17302                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17303                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17304                 }
17305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17306                 if (r->notifies) {
17307                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17308                 }
17309         }
17310         if (ndr_flags & NDR_BUFFERS) {
17311                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17312                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17313                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17314                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17315                 }
17316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17317         }
17318         return NDR_ERR_SUCCESS;
17319 }
17320
17321 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17322 {
17323         uint32_t cntr_notifies_0;
17324         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17325         ndr->depth++;
17326         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17327         ndr_print_uint32(ndr, "flags", r->flags);
17328         ndr_print_uint32(ndr, "count", r->count);
17329         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17330         ndr->depth++;
17331         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17332                 char *idx_0=NULL;
17333                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17334                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17335                         free(idx_0);
17336                 }
17337         }
17338         ndr->depth--;
17339         ndr->depth--;
17340 }
17341
17342 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17343 {
17344         if (ndr_flags & NDR_SCALARS) {
17345                 int level = ndr_push_get_switch_value(ndr, r);
17346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17347                 switch (level) {
17348                         case 0: {
17349                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17350                         break; }
17351
17352                         default:
17353                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17354                 }
17355         }
17356         if (ndr_flags & NDR_BUFFERS) {
17357                 int level = ndr_push_get_switch_value(ndr, r);
17358                 switch (level) {
17359                         case 0:
17360                                 if (r->info0) {
17361                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17362                                 }
17363                         break;
17364
17365                         default:
17366                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17367                 }
17368         }
17369         return NDR_ERR_SUCCESS;
17370 }
17371
17372 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17373 {
17374         int level;
17375         uint32_t _level;
17376         TALLOC_CTX *_mem_save_info0_0;
17377         level = ndr_pull_get_switch_value(ndr, r);
17378         if (ndr_flags & NDR_SCALARS) {
17379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17380                 if (_level != level) {
17381                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17382                 }
17383                 switch (level) {
17384                         case 0: {
17385                                 uint32_t _ptr_info0;
17386                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17387                                 if (_ptr_info0) {
17388                                         NDR_PULL_ALLOC(ndr, r->info0);
17389                                 } else {
17390                                         r->info0 = NULL;
17391                                 }
17392                         break; }
17393
17394                         default:
17395                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17396                 }
17397         }
17398         if (ndr_flags & NDR_BUFFERS) {
17399                 switch (level) {
17400                         case 0:
17401                                 if (r->info0) {
17402                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17403                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17404                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17405                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17406                                 }
17407                         break;
17408
17409                         default:
17410                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17411                 }
17412         }
17413         return NDR_ERR_SUCCESS;
17414 }
17415
17416 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17417 {
17418         int level;
17419         level = ndr_print_get_switch_value(ndr, r);
17420         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17421         switch (level) {
17422                 case 0:
17423                         ndr_print_ptr(ndr, "info0", r->info0);
17424                         ndr->depth++;
17425                         if (r->info0) {
17426                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17427                         }
17428                         ndr->depth--;
17429                 break;
17430
17431                 default:
17432                         ndr_print_bad_level(ndr, name, level);
17433         }
17434 }
17435
17436 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17437 {
17438         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17439         return NDR_ERR_SUCCESS;
17440 }
17441
17442 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17443 {
17444         uint32_t v;
17445         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17446         *r = v;
17447         return NDR_ERR_SUCCESS;
17448 }
17449
17450 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17451 {
17452         ndr_print_uint32(ndr, name, r);
17453         ndr->depth++;
17454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17457         ndr->depth--;
17458 }
17459
17460 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17461 {
17462         if (ndr_flags & NDR_SCALARS) {
17463                 NDR_CHECK(ndr_push_align(ndr, 4));
17464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17468                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17469                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17470                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17471         }
17472         if (ndr_flags & NDR_BUFFERS) {
17473                 if (r->client) {
17474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17478                 }
17479                 if (r->user) {
17480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17483                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17484                 }
17485         }
17486         return NDR_ERR_SUCCESS;
17487 }
17488
17489 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17490 {
17491         uint32_t _ptr_client;
17492         TALLOC_CTX *_mem_save_client_0;
17493         uint32_t _ptr_user;
17494         TALLOC_CTX *_mem_save_user_0;
17495         if (ndr_flags & NDR_SCALARS) {
17496                 NDR_CHECK(ndr_pull_align(ndr, 4));
17497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17499                 if (_ptr_client) {
17500                         NDR_PULL_ALLOC(ndr, r->client);
17501                 } else {
17502                         r->client = NULL;
17503                 }
17504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17505                 if (_ptr_user) {
17506                         NDR_PULL_ALLOC(ndr, r->user);
17507                 } else {
17508                         r->user = NULL;
17509                 }
17510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17511                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17512                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17513                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17514         }
17515         if (ndr_flags & NDR_BUFFERS) {
17516                 if (r->client) {
17517                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17518                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17519                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17520                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17521                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17522                                 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));
17523                         }
17524                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17525                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17527                 }
17528                 if (r->user) {
17529                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17530                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17533                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17534                                 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));
17535                         }
17536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17539                 }
17540         }
17541         return NDR_ERR_SUCCESS;
17542 }
17543
17544 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17545 {
17546         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17547         ndr->depth++;
17548         ndr_print_uint32(ndr, "size", r->size);
17549         ndr_print_ptr(ndr, "client", r->client);
17550         ndr->depth++;
17551         if (r->client) {
17552                 ndr_print_string(ndr, "client", r->client);
17553         }
17554         ndr->depth--;
17555         ndr_print_ptr(ndr, "user", r->user);
17556         ndr->depth++;
17557         if (r->user) {
17558                 ndr_print_string(ndr, "user", r->user);
17559         }
17560         ndr->depth--;
17561         ndr_print_uint32(ndr, "build", r->build);
17562         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17563         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17564         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17565         ndr->depth--;
17566 }
17567
17568 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17569 {
17570         if (ndr_flags & NDR_SCALARS) {
17571                 NDR_CHECK(ndr_push_align(ndr, 4));
17572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17573         }
17574         if (ndr_flags & NDR_BUFFERS) {
17575         }
17576         return NDR_ERR_SUCCESS;
17577 }
17578
17579 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17580 {
17581         if (ndr_flags & NDR_SCALARS) {
17582                 NDR_CHECK(ndr_pull_align(ndr, 4));
17583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17584         }
17585         if (ndr_flags & NDR_BUFFERS) {
17586         }
17587         return NDR_ERR_SUCCESS;
17588 }
17589
17590 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17591 {
17592         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17593         ndr->depth++;
17594         ndr_print_uint32(ndr, "not_used", r->not_used);
17595         ndr->depth--;
17596 }
17597
17598 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17599 {
17600         if (ndr_flags & NDR_SCALARS) {
17601                 NDR_CHECK(ndr_push_align(ndr, 4));
17602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17608                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17609                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17610                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17611                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17612         }
17613         if (ndr_flags & NDR_BUFFERS) {
17614                 if (r->client) {
17615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17618                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17619                 }
17620                 if (r->user) {
17621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17624                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17625                 }
17626         }
17627         return NDR_ERR_SUCCESS;
17628 }
17629
17630 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17631 {
17632         uint32_t _ptr_client;
17633         TALLOC_CTX *_mem_save_client_0;
17634         uint32_t _ptr_user;
17635         TALLOC_CTX *_mem_save_user_0;
17636         if (ndr_flags & NDR_SCALARS) {
17637                 NDR_CHECK(ndr_pull_align(ndr, 4));
17638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17642                 if (_ptr_client) {
17643                         NDR_PULL_ALLOC(ndr, r->client);
17644                 } else {
17645                         r->client = NULL;
17646                 }
17647                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17648                 if (_ptr_user) {
17649                         NDR_PULL_ALLOC(ndr, r->user);
17650                 } else {
17651                         r->user = NULL;
17652                 }
17653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17654                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17655                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17656                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17657                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17658         }
17659         if (ndr_flags & NDR_BUFFERS) {
17660                 if (r->client) {
17661                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17662                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17663                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17664                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17665                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17666                                 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));
17667                         }
17668                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17669                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17670                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17671                 }
17672                 if (r->user) {
17673                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17674                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17676                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17677                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17678                                 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));
17679                         }
17680                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17681                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17683                 }
17684         }
17685         return NDR_ERR_SUCCESS;
17686 }
17687
17688 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17689 {
17690         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17691         ndr->depth++;
17692         ndr_print_uint32(ndr, "size", r->size);
17693         ndr_print_uint32(ndr, "flags", r->flags);
17694         ndr_print_uint32(ndr, "size2", r->size2);
17695         ndr_print_ptr(ndr, "client", r->client);
17696         ndr->depth++;
17697         if (r->client) {
17698                 ndr_print_string(ndr, "client", r->client);
17699         }
17700         ndr->depth--;
17701         ndr_print_ptr(ndr, "user", r->user);
17702         ndr->depth++;
17703         if (r->user) {
17704                 ndr_print_string(ndr, "user", r->user);
17705         }
17706         ndr->depth--;
17707         ndr_print_uint32(ndr, "build", r->build);
17708         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17709         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17710         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17711         ndr_print_udlong(ndr, "reserved", r->reserved);
17712         ndr->depth--;
17713 }
17714
17715 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17716 {
17717         if (ndr_flags & NDR_SCALARS) {
17718                 int level = ndr_push_get_switch_value(ndr, r);
17719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17720                 switch (level) {
17721                         case 1: {
17722                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
17723                         break; }
17724
17725                         case 2: {
17726                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
17727                         break; }
17728
17729                         case 3: {
17730                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
17731                         break; }
17732
17733                         default:
17734                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17735                 }
17736         }
17737         if (ndr_flags & NDR_BUFFERS) {
17738                 int level = ndr_push_get_switch_value(ndr, r);
17739                 switch (level) {
17740                         case 1:
17741                                 if (r->level1) {
17742                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
17743                                 }
17744                         break;
17745
17746                         case 2:
17747                                 if (r->level2) {
17748                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
17749                                 }
17750                         break;
17751
17752                         case 3:
17753                                 if (r->level3) {
17754                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
17755                                 }
17756                         break;
17757
17758                         default:
17759                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17760                 }
17761         }
17762         return NDR_ERR_SUCCESS;
17763 }
17764
17765 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
17766 {
17767         int level;
17768         uint32_t _level;
17769         TALLOC_CTX *_mem_save_level1_0;
17770         TALLOC_CTX *_mem_save_level2_0;
17771         TALLOC_CTX *_mem_save_level3_0;
17772         level = ndr_pull_get_switch_value(ndr, r);
17773         if (ndr_flags & NDR_SCALARS) {
17774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17775                 if (_level != level) {
17776                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17777                 }
17778                 switch (level) {
17779                         case 1: {
17780                                 uint32_t _ptr_level1;
17781                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
17782                                 if (_ptr_level1) {
17783                                         NDR_PULL_ALLOC(ndr, r->level1);
17784                                 } else {
17785                                         r->level1 = NULL;
17786                                 }
17787                         break; }
17788
17789                         case 2: {
17790                                 uint32_t _ptr_level2;
17791                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
17792                                 if (_ptr_level2) {
17793                                         NDR_PULL_ALLOC(ndr, r->level2);
17794                                 } else {
17795                                         r->level2 = NULL;
17796                                 }
17797                         break; }
17798
17799                         case 3: {
17800                                 uint32_t _ptr_level3;
17801                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
17802                                 if (_ptr_level3) {
17803                                         NDR_PULL_ALLOC(ndr, r->level3);
17804                                 } else {
17805                                         r->level3 = NULL;
17806                                 }
17807                         break; }
17808
17809                         default:
17810                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17811                 }
17812         }
17813         if (ndr_flags & NDR_BUFFERS) {
17814                 switch (level) {
17815                         case 1:
17816                                 if (r->level1) {
17817                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
17818                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
17819                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
17820                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
17821                                 }
17822                         break;
17823
17824                         case 2:
17825                                 if (r->level2) {
17826                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
17827                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
17828                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
17829                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
17830                                 }
17831                         break;
17832
17833                         case 3:
17834                                 if (r->level3) {
17835                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
17836                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
17837                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
17838                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
17839                                 }
17840                         break;
17841
17842                         default:
17843                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17844                 }
17845         }
17846         return NDR_ERR_SUCCESS;
17847 }
17848
17849 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
17850 {
17851         int level;
17852         level = ndr_print_get_switch_value(ndr, r);
17853         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
17854         switch (level) {
17855                 case 1:
17856                         ndr_print_ptr(ndr, "level1", r->level1);
17857                         ndr->depth++;
17858                         if (r->level1) {
17859                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
17860                         }
17861                         ndr->depth--;
17862                 break;
17863
17864                 case 2:
17865                         ndr_print_ptr(ndr, "level2", r->level2);
17866                         ndr->depth++;
17867                         if (r->level2) {
17868                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
17869                         }
17870                         ndr->depth--;
17871                 break;
17872
17873                 case 3:
17874                         ndr_print_ptr(ndr, "level3", r->level3);
17875                         ndr->depth++;
17876                         if (r->level3) {
17877                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
17878                         }
17879                         ndr->depth--;
17880                 break;
17881
17882                 default:
17883                         ndr_print_bad_level(ndr, name, level);
17884         }
17885 }
17886
17887 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
17888 {
17889         if (ndr_flags & NDR_SCALARS) {
17890                 NDR_CHECK(ndr_push_align(ndr, 4));
17891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
17892                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
17893                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
17894         }
17895         if (ndr_flags & NDR_BUFFERS) {
17896                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
17897         }
17898         return NDR_ERR_SUCCESS;
17899 }
17900
17901 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
17902 {
17903         if (ndr_flags & NDR_SCALARS) {
17904                 NDR_CHECK(ndr_pull_align(ndr, 4));
17905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
17906                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
17907                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
17908         }
17909         if (ndr_flags & NDR_BUFFERS) {
17910                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
17911         }
17912         return NDR_ERR_SUCCESS;
17913 }
17914
17915 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
17916 {
17917         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
17918         ndr->depth++;
17919         ndr_print_uint32(ndr, "level", r->level);
17920         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
17921         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
17922         ndr->depth--;
17923 }
17924
17925 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17926 {
17927         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17928         return NDR_ERR_SUCCESS;
17929 }
17930
17931 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17932 {
17933         uint32_t v;
17934         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17935         *r = v;
17936         return NDR_ERR_SUCCESS;
17937 }
17938
17939 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
17940 {
17941         ndr_print_uint32(ndr, name, r);
17942         ndr->depth++;
17943         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
17944         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
17945         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
17946         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
17947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
17948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
17949         ndr->depth--;
17950 }
17951
17952 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17953 {
17954         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17955         return NDR_ERR_SUCCESS;
17956 }
17957
17958 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17959 {
17960         uint32_t v;
17961         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17962         *r = v;
17963         return NDR_ERR_SUCCESS;
17964 }
17965
17966 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17967 {
17968         ndr_print_uint32(ndr, name, r);
17969         ndr->depth++;
17970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
17971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
17972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
17973         ndr->depth--;
17974 }
17975
17976 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
17977 {
17978         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17979         return NDR_ERR_SUCCESS;
17980 }
17981
17982 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
17983 {
17984         uint32_t v;
17985         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17986         *r = v;
17987         return NDR_ERR_SUCCESS;
17988 }
17989
17990 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
17991 {
17992         const char *val = NULL;
17993
17994         switch (r) {
17995                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
17996                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
17997         }
17998         ndr_print_enum(ndr, name, "ENUM", val, r);
17999 }
18000
18001 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18002 {
18003         if (ndr_flags & NDR_SCALARS) {
18004                 NDR_CHECK(ndr_push_align(ndr, 4));
18005                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18007                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18010                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18011                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18013                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18014                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18015                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18016                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18020         }
18021         if (ndr_flags & NDR_BUFFERS) {
18022         }
18023         return NDR_ERR_SUCCESS;
18024 }
18025
18026 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18027 {
18028         if (ndr_flags & NDR_SCALARS) {
18029                 NDR_CHECK(ndr_pull_align(ndr, 4));
18030                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18032                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18035                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18036                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18038                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18039                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18040                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18041                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18045         }
18046         if (ndr_flags & NDR_BUFFERS) {
18047         }
18048         return NDR_ERR_SUCCESS;
18049 }
18050
18051 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18052 {
18053         ndr_print_struct(ndr, name, "spoolss_PortData1");
18054         ndr->depth++;
18055         ndr_print_string(ndr, "portname", r->portname);
18056         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18057         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18058         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18059         ndr_print_uint32(ndr, "reserved", r->reserved);
18060         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18061         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18062         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18063         ndr_print_string(ndr, "queue", r->queue);
18064         ndr_print_string(ndr, "ip_address", r->ip_address);
18065         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18066         ndr_print_string(ndr, "device_type", r->device_type);
18067         ndr_print_uint32(ndr, "port_number", r->port_number);
18068         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18069         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18070         ndr->depth--;
18071 }
18072
18073 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18074 {
18075         if (ndr_flags & NDR_SCALARS) {
18076                 NDR_CHECK(ndr_push_align(ndr, 4));
18077                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18079                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18082                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18083                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18085                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18086                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18091         }
18092         if (ndr_flags & NDR_BUFFERS) {
18093         }
18094         return NDR_ERR_SUCCESS;
18095 }
18096
18097 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18098 {
18099         if (ndr_flags & NDR_SCALARS) {
18100                 NDR_CHECK(ndr_pull_align(ndr, 4));
18101                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18103                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18106                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18107                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18109                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18110                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18115         }
18116         if (ndr_flags & NDR_BUFFERS) {
18117         }
18118         return NDR_ERR_SUCCESS;
18119 }
18120
18121 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18122 {
18123         ndr_print_struct(ndr, name, "spoolss_PortData2");
18124         ndr->depth++;
18125         ndr_print_string(ndr, "portname", r->portname);
18126         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18127         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18128         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18129         ndr_print_uint32(ndr, "reserved", r->reserved);
18130         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18131         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18132         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18133         ndr_print_string(ndr, "queue", r->queue);
18134         ndr_print_string(ndr, "device_type", r->device_type);
18135         ndr_print_uint32(ndr, "port_number", r->port_number);
18136         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18137         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18138         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18139         ndr->depth--;
18140 }
18141
18142 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18143 {
18144         if (ndr_flags & NDR_SCALARS) {
18145                 NDR_CHECK(ndr_push_align(ndr, 4));
18146                 {
18147                         uint32_t _flags_save_string = ndr->flags;
18148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18149                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18150                         ndr->flags = _flags_save_string;
18151                 }
18152         }
18153         if (ndr_flags & NDR_BUFFERS) {
18154         }
18155         return NDR_ERR_SUCCESS;
18156 }
18157
18158 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18159 {
18160         if (ndr_flags & NDR_SCALARS) {
18161                 NDR_CHECK(ndr_pull_align(ndr, 4));
18162                 {
18163                         uint32_t _flags_save_string = ndr->flags;
18164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18165                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18166                         ndr->flags = _flags_save_string;
18167                 }
18168         }
18169         if (ndr_flags & NDR_BUFFERS) {
18170         }
18171         return NDR_ERR_SUCCESS;
18172 }
18173
18174 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18175 {
18176         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18177         ndr->depth++;
18178         ndr_print_string(ndr, "dll_name", r->dll_name);
18179         ndr->depth--;
18180 }
18181
18182 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18183 {
18184         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18185         return NDR_ERR_SUCCESS;
18186 }
18187
18188 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18189 {
18190         uint32_t v;
18191         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18192         *r = v;
18193         return NDR_ERR_SUCCESS;
18194 }
18195
18196 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18197 {
18198         ndr_print_uint32(ndr, name, r);
18199         ndr->depth++;
18200         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18201         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18202         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18203         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18204         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18205         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18206         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18207         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18208         ndr->depth--;
18209 }
18210
18211 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18212 {
18213         if (flags & NDR_IN) {
18214                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18215                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18216                 if (r->in.server) {
18217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18221                 }
18222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18224                 if (r->in.buffer) {
18225                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18226                 }
18227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18228         }
18229         if (flags & NDR_OUT) {
18230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18231                 if (r->out.info) {
18232                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18233                 }
18234                 if (r->out.needed == NULL) {
18235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18236                 }
18237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18238                 if (r->out.count == NULL) {
18239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18240                 }
18241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18242                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18243         }
18244         return NDR_ERR_SUCCESS;
18245 }
18246
18247 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18248 {
18249         uint32_t _ptr_server;
18250         uint32_t _ptr_buffer;
18251         uint32_t _ptr_info;
18252         TALLOC_CTX *_mem_save_server_0;
18253         TALLOC_CTX *_mem_save_buffer_0;
18254         TALLOC_CTX *_mem_save_info_0;
18255         TALLOC_CTX *_mem_save_needed_0;
18256         TALLOC_CTX *_mem_save_count_0;
18257         if (flags & NDR_IN) {
18258                 ZERO_STRUCT(r->out);
18259
18260                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18262                 if (_ptr_server) {
18263                         NDR_PULL_ALLOC(ndr, r->in.server);
18264                 } else {
18265                         r->in.server = NULL;
18266                 }
18267                 if (r->in.server) {
18268                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18269                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18270                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18271                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18272                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18273                                 return 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));
18274                         }
18275                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18276                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18277                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18278                 }
18279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18281                 if (_ptr_buffer) {
18282                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18283                 } else {
18284                         r->in.buffer = NULL;
18285                 }
18286                 if (r->in.buffer) {
18287                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18288                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18289                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18291                 }
18292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18293                 NDR_PULL_ALLOC(ndr, r->out.needed);
18294                 ZERO_STRUCTP(r->out.needed);
18295                 NDR_PULL_ALLOC(ndr, r->out.count);
18296                 ZERO_STRUCTP(r->out.count);
18297         }
18298         if (flags & NDR_OUT) {
18299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18300                 if (_ptr_info) {
18301                         NDR_PULL_ALLOC(ndr, r->out.info);
18302                 } else {
18303                         r->out.info = NULL;
18304                 }
18305                 if (r->out.info) {
18306                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18307                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18308                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18310                 }
18311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18312                         NDR_PULL_ALLOC(ndr, r->out.needed);
18313                 }
18314                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18315                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18319                         NDR_PULL_ALLOC(ndr, r->out.count);
18320                 }
18321                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18322                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18325                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18326         }
18327         return NDR_ERR_SUCCESS;
18328 }
18329
18330 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18331 {
18332         uint32_t cntr_info_0;
18333         if (flags & NDR_IN) {
18334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18336         }
18337         if (flags & NDR_OUT) {
18338                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18339                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18340                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18341                 }
18342                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18343                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18344                 }
18345         }
18346         return NDR_ERR_SUCCESS;
18347 }
18348
18349 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18350 {
18351         uint32_t cntr_info_0;
18352         TALLOC_CTX *_mem_save_info_0;
18353         if (flags & NDR_IN) {
18354                 ZERO_STRUCT(r->out);
18355
18356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18358         }
18359         if (flags & NDR_OUT) {
18360                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18361                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18362                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18363                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18364                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18365                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18366                 }
18367                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18368                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18369                 }
18370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18371         }
18372         return NDR_ERR_SUCCESS;
18373 }
18374
18375 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18376 {
18377         uint32_t cntr_info_1;
18378         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18379         ndr->depth++;
18380         if (flags & NDR_SET_VALUES) {
18381                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18382         }
18383         if (flags & NDR_IN) {
18384                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18385                 ndr->depth++;
18386                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18387                 ndr_print_ptr(ndr, "server", r->in.server);
18388                 ndr->depth++;
18389                 if (r->in.server) {
18390                         ndr_print_string(ndr, "server", r->in.server);
18391                 }
18392                 ndr->depth--;
18393                 ndr_print_uint32(ndr, "level", r->in.level);
18394                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18395                 ndr->depth++;
18396                 if (r->in.buffer) {
18397                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18398                 }
18399                 ndr->depth--;
18400                 ndr_print_uint32(ndr, "offered", r->in.offered);
18401                 ndr->depth--;
18402         }
18403         if (flags & NDR_OUT) {
18404                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18405                 ndr->depth++;
18406                 ndr_print_ptr(ndr, "count", r->out.count);
18407                 ndr->depth++;
18408                 ndr_print_uint32(ndr, "count", *r->out.count);
18409                 ndr->depth--;
18410                 ndr_print_ptr(ndr, "info", r->out.info);
18411                 ndr->depth++;
18412                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18413                 ndr->depth++;
18414                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18415                         char *idx_1=NULL;
18416                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18417                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
18418                                 ndr->depth++;
18419                                 if (r->out.info[cntr_info_1]) {
18420                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
18421                                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info[cntr_info_1]);
18422                                 }
18423                                 ndr->depth--;
18424                                 free(idx_1);
18425                         }
18426                 }
18427                 ndr->depth--;
18428                 ndr->depth--;
18429                 ndr_print_ptr(ndr, "needed", r->out.needed);
18430                 ndr->depth++;
18431                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18432                 ndr->depth--;
18433                 ndr_print_WERROR(ndr, "result", r->out.result);
18434                 ndr->depth--;
18435         }
18436         ndr->depth--;
18437 }
18438
18439 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18440 {
18441         if (flags & NDR_IN) {
18442                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18443                 if (r->in.printername) {
18444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18447                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18448                 }
18449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18450                 if (r->in.datatype) {
18451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18455                 }
18456                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18457                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18458         }
18459         if (flags & NDR_OUT) {
18460                 if (r->out.handle == NULL) {
18461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18462                 }
18463                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18464                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18465         }
18466         return NDR_ERR_SUCCESS;
18467 }
18468
18469 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18470 {
18471         uint32_t _ptr_printername;
18472         uint32_t _ptr_datatype;
18473         TALLOC_CTX *_mem_save_printername_0;
18474         TALLOC_CTX *_mem_save_datatype_0;
18475         TALLOC_CTX *_mem_save_handle_0;
18476         if (flags & NDR_IN) {
18477                 ZERO_STRUCT(r->out);
18478
18479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18480                 if (_ptr_printername) {
18481                         NDR_PULL_ALLOC(ndr, r->in.printername);
18482                 } else {
18483                         r->in.printername = NULL;
18484                 }
18485                 if (r->in.printername) {
18486                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18487                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18490                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18491                                 return 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));
18492                         }
18493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18496                 }
18497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18498                 if (_ptr_datatype) {
18499                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18500                 } else {
18501                         r->in.datatype = NULL;
18502                 }
18503                 if (r->in.datatype) {
18504                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18505                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18508                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18509                                 return 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));
18510                         }
18511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18514                 }
18515                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18516                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18517                 NDR_PULL_ALLOC(ndr, r->out.handle);
18518                 ZERO_STRUCTP(r->out.handle);
18519         }
18520         if (flags & NDR_OUT) {
18521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18522                         NDR_PULL_ALLOC(ndr, r->out.handle);
18523                 }
18524                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18525                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18526                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18528                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18529         }
18530         return NDR_ERR_SUCCESS;
18531 }
18532
18533 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18534 {
18535         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18536         ndr->depth++;
18537         if (flags & NDR_SET_VALUES) {
18538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18539         }
18540         if (flags & NDR_IN) {
18541                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18542                 ndr->depth++;
18543                 ndr_print_ptr(ndr, "printername", r->in.printername);
18544                 ndr->depth++;
18545                 if (r->in.printername) {
18546                         ndr_print_string(ndr, "printername", r->in.printername);
18547                 }
18548                 ndr->depth--;
18549                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18550                 ndr->depth++;
18551                 if (r->in.datatype) {
18552                         ndr_print_string(ndr, "datatype", r->in.datatype);
18553                 }
18554                 ndr->depth--;
18555                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18556                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18557                 ndr->depth--;
18558         }
18559         if (flags & NDR_OUT) {
18560                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18561                 ndr->depth++;
18562                 ndr_print_ptr(ndr, "handle", r->out.handle);
18563                 ndr->depth++;
18564                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18565                 ndr->depth--;
18566                 ndr_print_WERROR(ndr, "result", r->out.result);
18567                 ndr->depth--;
18568         }
18569         ndr->depth--;
18570 }
18571
18572 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18573 {
18574         if (flags & NDR_IN) {
18575                 if (r->in.handle == NULL) {
18576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18577                 }
18578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18581                 if (r->in.ctr) {
18582                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18583                 }
18584                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18585         }
18586         if (flags & NDR_OUT) {
18587                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18588         }
18589         return NDR_ERR_SUCCESS;
18590 }
18591
18592 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18593 {
18594         uint32_t _ptr_ctr;
18595         TALLOC_CTX *_mem_save_handle_0;
18596         TALLOC_CTX *_mem_save_ctr_0;
18597         if (flags & NDR_IN) {
18598                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18599                         NDR_PULL_ALLOC(ndr, r->in.handle);
18600                 }
18601                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18602                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18603                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18607                 if (_ptr_ctr) {
18608                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18609                 } else {
18610                         r->in.ctr = NULL;
18611                 }
18612                 if (r->in.ctr) {
18613                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18614                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18615                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18617                 }
18618                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18619         }
18620         if (flags & NDR_OUT) {
18621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18622         }
18623         return NDR_ERR_SUCCESS;
18624 }
18625
18626 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18627 {
18628         ndr_print_struct(ndr, name, "spoolss_SetJob");
18629         ndr->depth++;
18630         if (flags & NDR_SET_VALUES) {
18631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18632         }
18633         if (flags & NDR_IN) {
18634                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18635                 ndr->depth++;
18636                 ndr_print_ptr(ndr, "handle", r->in.handle);
18637                 ndr->depth++;
18638                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18639                 ndr->depth--;
18640                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18641                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18642                 ndr->depth++;
18643                 if (r->in.ctr) {
18644                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18645                 }
18646                 ndr->depth--;
18647                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18648                 ndr->depth--;
18649         }
18650         if (flags & NDR_OUT) {
18651                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18652                 ndr->depth++;
18653                 ndr_print_WERROR(ndr, "result", r->out.result);
18654                 ndr->depth--;
18655         }
18656         ndr->depth--;
18657 }
18658
18659 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18660 {
18661         if (flags & NDR_IN) {
18662                 if (r->in.handle == NULL) {
18663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18664                 }
18665                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18669                 if (r->in.buffer) {
18670                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18671                 }
18672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18673         }
18674         if (flags & NDR_OUT) {
18675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18676                 if (r->out.info) {
18677                         {
18678                                 struct ndr_push *_ndr_info;
18679                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18680                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18681                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18682                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18683                         }
18684                 }
18685                 if (r->out.needed == NULL) {
18686                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18687                 }
18688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18689                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18690         }
18691         return NDR_ERR_SUCCESS;
18692 }
18693
18694 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18695 {
18696         uint32_t _ptr_buffer;
18697         uint32_t _ptr_info;
18698         TALLOC_CTX *_mem_save_handle_0;
18699         TALLOC_CTX *_mem_save_buffer_0;
18700         TALLOC_CTX *_mem_save_info_0;
18701         TALLOC_CTX *_mem_save_needed_0;
18702         if (flags & NDR_IN) {
18703                 ZERO_STRUCT(r->out);
18704
18705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18706                         NDR_PULL_ALLOC(ndr, r->in.handle);
18707                 }
18708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18715                 if (_ptr_buffer) {
18716                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18717                 } else {
18718                         r->in.buffer = NULL;
18719                 }
18720                 if (r->in.buffer) {
18721                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18722                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18723                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18725                 }
18726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18727                 NDR_PULL_ALLOC(ndr, r->out.needed);
18728                 ZERO_STRUCTP(r->out.needed);
18729         }
18730         if (flags & NDR_OUT) {
18731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18732                 if (_ptr_info) {
18733                         NDR_PULL_ALLOC(ndr, r->out.info);
18734                 } else {
18735                         r->out.info = NULL;
18736                 }
18737                 if (r->out.info) {
18738                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18739                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18740                         {
18741                                 struct ndr_pull *_ndr_info;
18742                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18743                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18744                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18745                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18746                         }
18747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18748                 }
18749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18750                         NDR_PULL_ALLOC(ndr, r->out.needed);
18751                 }
18752                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18753                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18757         }
18758         return NDR_ERR_SUCCESS;
18759 }
18760
18761 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
18762 {
18763         ndr_print_struct(ndr, name, "spoolss_GetJob");
18764         ndr->depth++;
18765         if (flags & NDR_SET_VALUES) {
18766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18767         }
18768         if (flags & NDR_IN) {
18769                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
18770                 ndr->depth++;
18771                 ndr_print_ptr(ndr, "handle", r->in.handle);
18772                 ndr->depth++;
18773                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18774                 ndr->depth--;
18775                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18776                 ndr_print_uint32(ndr, "level", r->in.level);
18777                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18778                 ndr->depth++;
18779                 if (r->in.buffer) {
18780                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18781                 }
18782                 ndr->depth--;
18783                 ndr_print_uint32(ndr, "offered", r->in.offered);
18784                 ndr->depth--;
18785         }
18786         if (flags & NDR_OUT) {
18787                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
18788                 ndr->depth++;
18789                 ndr_print_ptr(ndr, "info", r->out.info);
18790                 ndr->depth++;
18791                 if (r->out.info) {
18792                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18793                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
18794                 }
18795                 ndr->depth--;
18796                 ndr_print_ptr(ndr, "needed", r->out.needed);
18797                 ndr->depth++;
18798                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18799                 ndr->depth--;
18800                 ndr_print_WERROR(ndr, "result", r->out.result);
18801                 ndr->depth--;
18802         }
18803         ndr->depth--;
18804 }
18805
18806 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
18807 {
18808         if (flags & NDR_IN) {
18809                 if (r->in.handle == NULL) {
18810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18811                 }
18812                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
18814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
18815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18817                 if (r->in.buffer) {
18818                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18819                 }
18820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18821         }
18822         if (flags & NDR_OUT) {
18823                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18824                 if (r->out.info) {
18825                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18826                 }
18827                 if (r->out.needed == NULL) {
18828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18829                 }
18830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18831                 if (r->out.count == NULL) {
18832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18833                 }
18834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18836         }
18837         return NDR_ERR_SUCCESS;
18838 }
18839
18840 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
18841 {
18842         uint32_t _ptr_buffer;
18843         uint32_t _ptr_info;
18844         TALLOC_CTX *_mem_save_handle_0;
18845         TALLOC_CTX *_mem_save_buffer_0;
18846         TALLOC_CTX *_mem_save_info_0;
18847         TALLOC_CTX *_mem_save_needed_0;
18848         TALLOC_CTX *_mem_save_count_0;
18849         if (flags & NDR_IN) {
18850                 ZERO_STRUCT(r->out);
18851
18852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18853                         NDR_PULL_ALLOC(ndr, r->in.handle);
18854                 }
18855                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18856                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18857                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
18860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
18861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18862                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18863                 if (_ptr_buffer) {
18864                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18865                 } else {
18866                         r->in.buffer = NULL;
18867                 }
18868                 if (r->in.buffer) {
18869                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18870                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18871                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18873                 }
18874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18875                 NDR_PULL_ALLOC(ndr, r->out.needed);
18876                 ZERO_STRUCTP(r->out.needed);
18877                 NDR_PULL_ALLOC(ndr, r->out.count);
18878                 ZERO_STRUCTP(r->out.count);
18879         }
18880         if (flags & NDR_OUT) {
18881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18882                 if (_ptr_info) {
18883                         NDR_PULL_ALLOC(ndr, r->out.info);
18884                 } else {
18885                         r->out.info = NULL;
18886                 }
18887                 if (r->out.info) {
18888                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18889                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18890                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18892                 }
18893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18894                         NDR_PULL_ALLOC(ndr, r->out.needed);
18895                 }
18896                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18897                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18900                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18901                         NDR_PULL_ALLOC(ndr, r->out.count);
18902                 }
18903                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18904                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18908         }
18909         return NDR_ERR_SUCCESS;
18910 }
18911
18912 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
18913 {
18914         uint32_t cntr_info_0;
18915         if (flags & NDR_IN) {
18916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18918         }
18919         if (flags & NDR_OUT) {
18920                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18921                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18922                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18923                 }
18924                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18925                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18926                 }
18927         }
18928         return NDR_ERR_SUCCESS;
18929 }
18930
18931 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
18932 {
18933         uint32_t cntr_info_0;
18934         TALLOC_CTX *_mem_save_info_0;
18935         if (flags & NDR_IN) {
18936                 ZERO_STRUCT(r->out);
18937
18938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18940         }
18941         if (flags & NDR_OUT) {
18942                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18943                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18944                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18945                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18946                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18947                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18948                 }
18949                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18950                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18951                 }
18952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18953         }
18954         return NDR_ERR_SUCCESS;
18955 }
18956
18957 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
18958 {
18959         uint32_t cntr_info_1;
18960         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
18961         ndr->depth++;
18962         if (flags & NDR_SET_VALUES) {
18963                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18964         }
18965         if (flags & NDR_IN) {
18966                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
18967                 ndr->depth++;
18968                 ndr_print_ptr(ndr, "handle", r->in.handle);
18969                 ndr->depth++;
18970                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18971                 ndr->depth--;
18972                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
18973                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
18974                 ndr_print_uint32(ndr, "level", r->in.level);
18975                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18976                 ndr->depth++;
18977                 if (r->in.buffer) {
18978                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18979                 }
18980                 ndr->depth--;
18981                 ndr_print_uint32(ndr, "offered", r->in.offered);
18982                 ndr->depth--;
18983         }
18984         if (flags & NDR_OUT) {
18985                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
18986                 ndr->depth++;
18987                 ndr_print_ptr(ndr, "count", r->out.count);
18988                 ndr->depth++;
18989                 ndr_print_uint32(ndr, "count", *r->out.count);
18990                 ndr->depth--;
18991                 ndr_print_ptr(ndr, "info", r->out.info);
18992                 ndr->depth++;
18993                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18994                 ndr->depth++;
18995                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18996                         char *idx_1=NULL;
18997                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18998                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
18999                                 ndr->depth++;
19000                                 if (r->out.info[cntr_info_1]) {
19001                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
19002                                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info[cntr_info_1]);
19003                                 }
19004                                 ndr->depth--;
19005                                 free(idx_1);
19006                         }
19007                 }
19008                 ndr->depth--;
19009                 ndr->depth--;
19010                 ndr_print_ptr(ndr, "needed", r->out.needed);
19011                 ndr->depth++;
19012                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19013                 ndr->depth--;
19014                 ndr_print_WERROR(ndr, "result", r->out.result);
19015                 ndr->depth--;
19016         }
19017         ndr->depth--;
19018 }
19019
19020 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19021 {
19022         if (flags & NDR_IN) {
19023         }
19024         if (flags & NDR_OUT) {
19025                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19026         }
19027         return NDR_ERR_SUCCESS;
19028 }
19029
19030 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19031 {
19032         if (flags & NDR_IN) {
19033         }
19034         if (flags & NDR_OUT) {
19035                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19036         }
19037         return NDR_ERR_SUCCESS;
19038 }
19039
19040 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19041 {
19042         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19043         ndr->depth++;
19044         if (flags & NDR_SET_VALUES) {
19045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19046         }
19047         if (flags & NDR_IN) {
19048                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19049                 ndr->depth++;
19050                 ndr->depth--;
19051         }
19052         if (flags & NDR_OUT) {
19053                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19054                 ndr->depth++;
19055                 ndr_print_WERROR(ndr, "result", r->out.result);
19056                 ndr->depth--;
19057         }
19058         ndr->depth--;
19059 }
19060
19061 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19062 {
19063         if (flags & NDR_IN) {
19064                 if (r->in.handle == NULL) {
19065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19066                 }
19067                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19068         }
19069         if (flags & NDR_OUT) {
19070                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19071         }
19072         return NDR_ERR_SUCCESS;
19073 }
19074
19075 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19076 {
19077         TALLOC_CTX *_mem_save_handle_0;
19078         if (flags & NDR_IN) {
19079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19080                         NDR_PULL_ALLOC(ndr, r->in.handle);
19081                 }
19082                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19083                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19084                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19085                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19086         }
19087         if (flags & NDR_OUT) {
19088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19089         }
19090         return NDR_ERR_SUCCESS;
19091 }
19092
19093 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19094 {
19095         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19096         ndr->depth++;
19097         if (flags & NDR_SET_VALUES) {
19098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19099         }
19100         if (flags & NDR_IN) {
19101                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19102                 ndr->depth++;
19103                 ndr_print_ptr(ndr, "handle", r->in.handle);
19104                 ndr->depth++;
19105                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19106                 ndr->depth--;
19107                 ndr->depth--;
19108         }
19109         if (flags & NDR_OUT) {
19110                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19111                 ndr->depth++;
19112                 ndr_print_WERROR(ndr, "result", r->out.result);
19113                 ndr->depth--;
19114         }
19115         ndr->depth--;
19116 }
19117
19118 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19119 {
19120         if (flags & NDR_IN) {
19121                 if (r->in.handle == NULL) {
19122                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19123                 }
19124                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19125                 if (r->in.info_ctr == NULL) {
19126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19127                 }
19128                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19129                 if (r->in.devmode_ctr == NULL) {
19130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19131                 }
19132                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19133                 if (r->in.secdesc_ctr == NULL) {
19134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19135                 }
19136                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19137                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19138         }
19139         if (flags & NDR_OUT) {
19140                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19141         }
19142         return NDR_ERR_SUCCESS;
19143 }
19144
19145 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19146 {
19147         TALLOC_CTX *_mem_save_handle_0;
19148         TALLOC_CTX *_mem_save_info_ctr_0;
19149         TALLOC_CTX *_mem_save_devmode_ctr_0;
19150         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19151         if (flags & NDR_IN) {
19152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19153                         NDR_PULL_ALLOC(ndr, r->in.handle);
19154                 }
19155                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19156                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19157                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19160                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19161                 }
19162                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19163                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19164                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19167                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19168                 }
19169                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19170                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19171                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19174                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19175                 }
19176                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19177                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19178                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19180                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19181         }
19182         if (flags & NDR_OUT) {
19183                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19184         }
19185         return NDR_ERR_SUCCESS;
19186 }
19187
19188 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19189 {
19190         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19191         ndr->depth++;
19192         if (flags & NDR_SET_VALUES) {
19193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19194         }
19195         if (flags & NDR_IN) {
19196                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19197                 ndr->depth++;
19198                 ndr_print_ptr(ndr, "handle", r->in.handle);
19199                 ndr->depth++;
19200                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19201                 ndr->depth--;
19202                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19203                 ndr->depth++;
19204                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19205                 ndr->depth--;
19206                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19207                 ndr->depth++;
19208                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19209                 ndr->depth--;
19210                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19211                 ndr->depth++;
19212                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19213                 ndr->depth--;
19214                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19215                 ndr->depth--;
19216         }
19217         if (flags & NDR_OUT) {
19218                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19219                 ndr->depth++;
19220                 ndr_print_WERROR(ndr, "result", r->out.result);
19221                 ndr->depth--;
19222         }
19223         ndr->depth--;
19224 }
19225
19226 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19227 {
19228         if (flags & NDR_IN) {
19229                 if (r->in.handle == NULL) {
19230                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19231                 }
19232                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19235                 if (r->in.buffer) {
19236                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19237                 }
19238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19239         }
19240         if (flags & NDR_OUT) {
19241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19242                 if (r->out.info) {
19243                         {
19244                                 struct ndr_push *_ndr_info;
19245                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19246                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19247                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19248                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19249                         }
19250                 }
19251                 if (r->out.needed == NULL) {
19252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19253                 }
19254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19255                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19256         }
19257         return NDR_ERR_SUCCESS;
19258 }
19259
19260 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19261 {
19262         uint32_t _ptr_buffer;
19263         uint32_t _ptr_info;
19264         TALLOC_CTX *_mem_save_handle_0;
19265         TALLOC_CTX *_mem_save_buffer_0;
19266         TALLOC_CTX *_mem_save_info_0;
19267         TALLOC_CTX *_mem_save_needed_0;
19268         if (flags & NDR_IN) {
19269                 ZERO_STRUCT(r->out);
19270
19271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19272                         NDR_PULL_ALLOC(ndr, r->in.handle);
19273                 }
19274                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19275                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19276                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19280                 if (_ptr_buffer) {
19281                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19282                 } else {
19283                         r->in.buffer = NULL;
19284                 }
19285                 if (r->in.buffer) {
19286                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19287                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19288                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19290                 }
19291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19292                 NDR_PULL_ALLOC(ndr, r->out.needed);
19293                 ZERO_STRUCTP(r->out.needed);
19294         }
19295         if (flags & NDR_OUT) {
19296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19297                 if (_ptr_info) {
19298                         NDR_PULL_ALLOC(ndr, r->out.info);
19299                 } else {
19300                         r->out.info = NULL;
19301                 }
19302                 if (r->out.info) {
19303                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19304                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19305                         {
19306                                 struct ndr_pull *_ndr_info;
19307                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19308                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19309                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19310                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19311                         }
19312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19313                 }
19314                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19315                         NDR_PULL_ALLOC(ndr, r->out.needed);
19316                 }
19317                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19318                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19320                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19321                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19322         }
19323         return NDR_ERR_SUCCESS;
19324 }
19325
19326 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19327 {
19328         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19329         ndr->depth++;
19330         if (flags & NDR_SET_VALUES) {
19331                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19332         }
19333         if (flags & NDR_IN) {
19334                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19335                 ndr->depth++;
19336                 ndr_print_ptr(ndr, "handle", r->in.handle);
19337                 ndr->depth++;
19338                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19339                 ndr->depth--;
19340                 ndr_print_uint32(ndr, "level", r->in.level);
19341                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19342                 ndr->depth++;
19343                 if (r->in.buffer) {
19344                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19345                 }
19346                 ndr->depth--;
19347                 ndr_print_uint32(ndr, "offered", r->in.offered);
19348                 ndr->depth--;
19349         }
19350         if (flags & NDR_OUT) {
19351                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19352                 ndr->depth++;
19353                 ndr_print_ptr(ndr, "info", r->out.info);
19354                 ndr->depth++;
19355                 if (r->out.info) {
19356                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19357                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19358                 }
19359                 ndr->depth--;
19360                 ndr_print_ptr(ndr, "needed", r->out.needed);
19361                 ndr->depth++;
19362                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19363                 ndr->depth--;
19364                 ndr_print_WERROR(ndr, "result", r->out.result);
19365                 ndr->depth--;
19366         }
19367         ndr->depth--;
19368 }
19369
19370 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19371 {
19372         if (flags & NDR_IN) {
19373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19374                 if (r->in.servername) {
19375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19378                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19379                 }
19380                 if (r->in.info_ctr == NULL) {
19381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19382                 }
19383                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19384         }
19385         if (flags & NDR_OUT) {
19386                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19387         }
19388         return NDR_ERR_SUCCESS;
19389 }
19390
19391 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19392 {
19393         uint32_t _ptr_servername;
19394         TALLOC_CTX *_mem_save_servername_0;
19395         TALLOC_CTX *_mem_save_info_ctr_0;
19396         if (flags & NDR_IN) {
19397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19398                 if (_ptr_servername) {
19399                         NDR_PULL_ALLOC(ndr, r->in.servername);
19400                 } else {
19401                         r->in.servername = NULL;
19402                 }
19403                 if (r->in.servername) {
19404                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19405                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19407                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19408                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19409                                 return 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));
19410                         }
19411                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19412                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19414                 }
19415                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19416                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19417                 }
19418                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19419                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19420                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19422         }
19423         if (flags & NDR_OUT) {
19424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19425         }
19426         return NDR_ERR_SUCCESS;
19427 }
19428
19429 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19430 {
19431         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19432         ndr->depth++;
19433         if (flags & NDR_SET_VALUES) {
19434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19435         }
19436         if (flags & NDR_IN) {
19437                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19438                 ndr->depth++;
19439                 ndr_print_ptr(ndr, "servername", r->in.servername);
19440                 ndr->depth++;
19441                 if (r->in.servername) {
19442                         ndr_print_string(ndr, "servername", r->in.servername);
19443                 }
19444                 ndr->depth--;
19445                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19446                 ndr->depth++;
19447                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19448                 ndr->depth--;
19449                 ndr->depth--;
19450         }
19451         if (flags & NDR_OUT) {
19452                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19453                 ndr->depth++;
19454                 ndr_print_WERROR(ndr, "result", r->out.result);
19455                 ndr->depth--;
19456         }
19457         ndr->depth--;
19458 }
19459
19460 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19461 {
19462         if (flags & NDR_IN) {
19463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19464                 if (r->in.server) {
19465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19469                 }
19470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19471                 if (r->in.environment) {
19472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19476                 }
19477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19479                 if (r->in.buffer) {
19480                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19481                 }
19482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19483         }
19484         if (flags & NDR_OUT) {
19485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19486                 if (r->out.info) {
19487                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19488                 }
19489                 if (r->out.needed == NULL) {
19490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19491                 }
19492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19493                 if (r->out.count == NULL) {
19494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19495                 }
19496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19497                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19498         }
19499         return NDR_ERR_SUCCESS;
19500 }
19501
19502 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19503 {
19504         uint32_t _ptr_server;
19505         uint32_t _ptr_environment;
19506         uint32_t _ptr_buffer;
19507         uint32_t _ptr_info;
19508         TALLOC_CTX *_mem_save_server_0;
19509         TALLOC_CTX *_mem_save_environment_0;
19510         TALLOC_CTX *_mem_save_buffer_0;
19511         TALLOC_CTX *_mem_save_info_0;
19512         TALLOC_CTX *_mem_save_needed_0;
19513         TALLOC_CTX *_mem_save_count_0;
19514         if (flags & NDR_IN) {
19515                 ZERO_STRUCT(r->out);
19516
19517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19518                 if (_ptr_server) {
19519                         NDR_PULL_ALLOC(ndr, r->in.server);
19520                 } else {
19521                         r->in.server = NULL;
19522                 }
19523                 if (r->in.server) {
19524                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19525                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19528                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19529                                 return 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));
19530                         }
19531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19534                 }
19535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19536                 if (_ptr_environment) {
19537                         NDR_PULL_ALLOC(ndr, r->in.environment);
19538                 } else {
19539                         r->in.environment = NULL;
19540                 }
19541                 if (r->in.environment) {
19542                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19543                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19544                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19545                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19546                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19547                                 return 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));
19548                         }
19549                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19550                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19552                 }
19553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19555                 if (_ptr_buffer) {
19556                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19557                 } else {
19558                         r->in.buffer = NULL;
19559                 }
19560                 if (r->in.buffer) {
19561                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19562                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19563                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19565                 }
19566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19567                 NDR_PULL_ALLOC(ndr, r->out.needed);
19568                 ZERO_STRUCTP(r->out.needed);
19569                 NDR_PULL_ALLOC(ndr, r->out.count);
19570                 ZERO_STRUCTP(r->out.count);
19571         }
19572         if (flags & NDR_OUT) {
19573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19574                 if (_ptr_info) {
19575                         NDR_PULL_ALLOC(ndr, r->out.info);
19576                 } else {
19577                         r->out.info = NULL;
19578                 }
19579                 if (r->out.info) {
19580                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19581                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19582                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19584                 }
19585                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19586                         NDR_PULL_ALLOC(ndr, r->out.needed);
19587                 }
19588                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19589                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19592                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19593                         NDR_PULL_ALLOC(ndr, r->out.count);
19594                 }
19595                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19596                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19599                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19600         }
19601         return NDR_ERR_SUCCESS;
19602 }
19603
19604 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19605 {
19606         uint32_t cntr_info_0;
19607         if (flags & NDR_IN) {
19608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19610         }
19611         if (flags & NDR_OUT) {
19612                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19613                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19614                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19615                 }
19616                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19617                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19618                 }
19619         }
19620         return NDR_ERR_SUCCESS;
19621 }
19622
19623 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19624 {
19625         uint32_t cntr_info_0;
19626         TALLOC_CTX *_mem_save_info_0;
19627         if (flags & NDR_IN) {
19628                 ZERO_STRUCT(r->out);
19629
19630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19632         }
19633         if (flags & NDR_OUT) {
19634                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19635                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19636                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19637                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19638                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19639                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19640                 }
19641                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19642                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19643                 }
19644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19645         }
19646         return NDR_ERR_SUCCESS;
19647 }
19648
19649 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19650 {
19651         uint32_t cntr_info_1;
19652         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19653         ndr->depth++;
19654         if (flags & NDR_SET_VALUES) {
19655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19656         }
19657         if (flags & NDR_IN) {
19658                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19659                 ndr->depth++;
19660                 ndr_print_ptr(ndr, "server", r->in.server);
19661                 ndr->depth++;
19662                 if (r->in.server) {
19663                         ndr_print_string(ndr, "server", r->in.server);
19664                 }
19665                 ndr->depth--;
19666                 ndr_print_ptr(ndr, "environment", r->in.environment);
19667                 ndr->depth++;
19668                 if (r->in.environment) {
19669                         ndr_print_string(ndr, "environment", r->in.environment);
19670                 }
19671                 ndr->depth--;
19672                 ndr_print_uint32(ndr, "level", r->in.level);
19673                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19674                 ndr->depth++;
19675                 if (r->in.buffer) {
19676                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19677                 }
19678                 ndr->depth--;
19679                 ndr_print_uint32(ndr, "offered", r->in.offered);
19680                 ndr->depth--;
19681         }
19682         if (flags & NDR_OUT) {
19683                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19684                 ndr->depth++;
19685                 ndr_print_ptr(ndr, "count", r->out.count);
19686                 ndr->depth++;
19687                 ndr_print_uint32(ndr, "count", *r->out.count);
19688                 ndr->depth--;
19689                 ndr_print_ptr(ndr, "info", r->out.info);
19690                 ndr->depth++;
19691                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19692                 ndr->depth++;
19693                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
19694                         char *idx_1=NULL;
19695                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
19696                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
19697                                 ndr->depth++;
19698                                 if (r->out.info[cntr_info_1]) {
19699                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
19700                                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info[cntr_info_1]);
19701                                 }
19702                                 ndr->depth--;
19703                                 free(idx_1);
19704                         }
19705                 }
19706                 ndr->depth--;
19707                 ndr->depth--;
19708                 ndr_print_ptr(ndr, "needed", r->out.needed);
19709                 ndr->depth++;
19710                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19711                 ndr->depth--;
19712                 ndr_print_WERROR(ndr, "result", r->out.result);
19713                 ndr->depth--;
19714         }
19715         ndr->depth--;
19716 }
19717
19718 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
19719 {
19720         if (flags & NDR_IN) {
19721         }
19722         if (flags & NDR_OUT) {
19723                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19724         }
19725         return NDR_ERR_SUCCESS;
19726 }
19727
19728 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
19729 {
19730         if (flags & NDR_IN) {
19731         }
19732         if (flags & NDR_OUT) {
19733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19734         }
19735         return NDR_ERR_SUCCESS;
19736 }
19737
19738 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
19739 {
19740         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
19741         ndr->depth++;
19742         if (flags & NDR_SET_VALUES) {
19743                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19744         }
19745         if (flags & NDR_IN) {
19746                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
19747                 ndr->depth++;
19748                 ndr->depth--;
19749         }
19750         if (flags & NDR_OUT) {
19751                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
19752                 ndr->depth++;
19753                 ndr_print_WERROR(ndr, "result", r->out.result);
19754                 ndr->depth--;
19755         }
19756         ndr->depth--;
19757 }
19758
19759 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
19760 {
19761         if (flags & NDR_IN) {
19762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19763                 if (r->in.server) {
19764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19768                 }
19769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19770                 if (r->in.environment) {
19771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19774                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19775                 }
19776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19778                 if (r->in.buffer) {
19779                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19780                 }
19781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19782         }
19783         if (flags & NDR_OUT) {
19784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19785                 if (r->out.info) {
19786                         {
19787                                 struct ndr_push *_ndr_info;
19788                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19789                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19790                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
19791                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19792                         }
19793                 }
19794                 if (r->out.needed == NULL) {
19795                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19796                 }
19797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19798                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19799         }
19800         return NDR_ERR_SUCCESS;
19801 }
19802
19803 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
19804 {
19805         uint32_t _ptr_server;
19806         uint32_t _ptr_environment;
19807         uint32_t _ptr_buffer;
19808         uint32_t _ptr_info;
19809         TALLOC_CTX *_mem_save_server_0;
19810         TALLOC_CTX *_mem_save_environment_0;
19811         TALLOC_CTX *_mem_save_buffer_0;
19812         TALLOC_CTX *_mem_save_info_0;
19813         TALLOC_CTX *_mem_save_needed_0;
19814         if (flags & NDR_IN) {
19815                 ZERO_STRUCT(r->out);
19816
19817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19818                 if (_ptr_server) {
19819                         NDR_PULL_ALLOC(ndr, r->in.server);
19820                 } else {
19821                         r->in.server = NULL;
19822                 }
19823                 if (r->in.server) {
19824                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19828                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19829                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
19830                         }
19831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19832                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19834                 }
19835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19836                 if (_ptr_environment) {
19837                         NDR_PULL_ALLOC(ndr, r->in.environment);
19838                 } else {
19839                         r->in.environment = NULL;
19840                 }
19841                 if (r->in.environment) {
19842                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19843                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19845                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19846                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19847                                 return 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));
19848                         }
19849                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19850                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19852                 }
19853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19855                 if (_ptr_buffer) {
19856                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19857                 } else {
19858                         r->in.buffer = NULL;
19859                 }
19860                 if (r->in.buffer) {
19861                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19863                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19865                 }
19866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19867                 NDR_PULL_ALLOC(ndr, r->out.needed);
19868                 ZERO_STRUCTP(r->out.needed);
19869         }
19870         if (flags & NDR_OUT) {
19871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19872                 if (_ptr_info) {
19873                         NDR_PULL_ALLOC(ndr, r->out.info);
19874                 } else {
19875                         r->out.info = NULL;
19876                 }
19877                 if (r->out.info) {
19878                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19879                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19880                         {
19881                                 struct ndr_pull *_ndr_info;
19882                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19883                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19884                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
19885                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19886                         }
19887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19888                 }
19889                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19890                         NDR_PULL_ALLOC(ndr, r->out.needed);
19891                 }
19892                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19893                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19895                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19896                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19897         }
19898         return NDR_ERR_SUCCESS;
19899 }
19900
19901 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
19902 {
19903         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
19904         ndr->depth++;
19905         if (flags & NDR_SET_VALUES) {
19906                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19907         }
19908         if (flags & NDR_IN) {
19909                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
19910                 ndr->depth++;
19911                 ndr_print_ptr(ndr, "server", r->in.server);
19912                 ndr->depth++;
19913                 if (r->in.server) {
19914                         ndr_print_string(ndr, "server", r->in.server);
19915                 }
19916                 ndr->depth--;
19917                 ndr_print_ptr(ndr, "environment", r->in.environment);
19918                 ndr->depth++;
19919                 if (r->in.environment) {
19920                         ndr_print_string(ndr, "environment", r->in.environment);
19921                 }
19922                 ndr->depth--;
19923                 ndr_print_uint32(ndr, "level", r->in.level);
19924                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19925                 ndr->depth++;
19926                 if (r->in.buffer) {
19927                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19928                 }
19929                 ndr->depth--;
19930                 ndr_print_uint32(ndr, "offered", r->in.offered);
19931                 ndr->depth--;
19932         }
19933         if (flags & NDR_OUT) {
19934                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
19935                 ndr->depth++;
19936                 ndr_print_ptr(ndr, "info", r->out.info);
19937                 ndr->depth++;
19938                 if (r->out.info) {
19939                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19940                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
19941                 }
19942                 ndr->depth--;
19943                 ndr_print_ptr(ndr, "needed", r->out.needed);
19944                 ndr->depth++;
19945                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19946                 ndr->depth--;
19947                 ndr_print_WERROR(ndr, "result", r->out.result);
19948                 ndr->depth--;
19949         }
19950         ndr->depth--;
19951 }
19952
19953 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
19954 {
19955         if (flags & NDR_IN) {
19956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19957                 if (r->in.server) {
19958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19962                 }
19963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
19966                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
19968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
19970                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19971         }
19972         if (flags & NDR_OUT) {
19973                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19974         }
19975         return NDR_ERR_SUCCESS;
19976 }
19977
19978 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
19979 {
19980         uint32_t _ptr_server;
19981         TALLOC_CTX *_mem_save_server_0;
19982         if (flags & NDR_IN) {
19983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19984                 if (_ptr_server) {
19985                         NDR_PULL_ALLOC(ndr, r->in.server);
19986                 } else {
19987                         r->in.server = NULL;
19988                 }
19989                 if (r->in.server) {
19990                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19991                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19994                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19995                                 return 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));
19996                         }
19997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20000                 }
20001                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20002                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20003                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20004                         return 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));
20005                 }
20006                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20007                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20008                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20009                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20010                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20011                         return 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));
20012                 }
20013                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20014                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20015         }
20016         if (flags & NDR_OUT) {
20017                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20018         }
20019         return NDR_ERR_SUCCESS;
20020 }
20021
20022 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20023 {
20024         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20025         ndr->depth++;
20026         if (flags & NDR_SET_VALUES) {
20027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20028         }
20029         if (flags & NDR_IN) {
20030                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20031                 ndr->depth++;
20032                 ndr_print_ptr(ndr, "server", r->in.server);
20033                 ndr->depth++;
20034                 if (r->in.server) {
20035                         ndr_print_string(ndr, "server", r->in.server);
20036                 }
20037                 ndr->depth--;
20038                 ndr_print_string(ndr, "architecture", r->in.architecture);
20039                 ndr_print_string(ndr, "driver", r->in.driver);
20040                 ndr->depth--;
20041         }
20042         if (flags & NDR_OUT) {
20043                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20044                 ndr->depth++;
20045                 ndr_print_WERROR(ndr, "result", r->out.result);
20046                 ndr->depth--;
20047         }
20048         ndr->depth--;
20049 }
20050
20051 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20052 {
20053         if (flags & NDR_IN) {
20054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20055                 if (r->in.server) {
20056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20060                 }
20061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20064                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20068                 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));
20069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20072                 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));
20073         }
20074         if (flags & NDR_OUT) {
20075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20076         }
20077         return NDR_ERR_SUCCESS;
20078 }
20079
20080 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20081 {
20082         uint32_t _ptr_server;
20083         TALLOC_CTX *_mem_save_server_0;
20084         if (flags & NDR_IN) {
20085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20086                 if (_ptr_server) {
20087                         NDR_PULL_ALLOC(ndr, r->in.server);
20088                 } else {
20089                         r->in.server = NULL;
20090                 }
20091                 if (r->in.server) {
20092                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20093                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20094                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20095                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20096                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20097                                 return 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));
20098                         }
20099                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20100                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20102                 }
20103                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20104                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20105                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20106                         return 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));
20107                 }
20108                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20109                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20110                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20111                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20112                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20113                         return 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));
20114                 }
20115                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20116                 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));
20117                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20118                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20119                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20120                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
20121                 }
20122                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20123                 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));
20124         }
20125         if (flags & NDR_OUT) {
20126                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20127         }
20128         return NDR_ERR_SUCCESS;
20129 }
20130
20131 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20132 {
20133         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20134         ndr->depth++;
20135         if (flags & NDR_SET_VALUES) {
20136                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20137         }
20138         if (flags & NDR_IN) {
20139                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20140                 ndr->depth++;
20141                 ndr_print_ptr(ndr, "server", r->in.server);
20142                 ndr->depth++;
20143                 if (r->in.server) {
20144                         ndr_print_string(ndr, "server", r->in.server);
20145                 }
20146                 ndr->depth--;
20147                 ndr_print_string(ndr, "architecture", r->in.architecture);
20148                 ndr_print_string(ndr, "path_name", r->in.path_name);
20149                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20150                 ndr->depth--;
20151         }
20152         if (flags & NDR_OUT) {
20153                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20154                 ndr->depth++;
20155                 ndr_print_WERROR(ndr, "result", r->out.result);
20156                 ndr->depth--;
20157         }
20158         ndr->depth--;
20159 }
20160
20161 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20162 {
20163         if (flags & NDR_IN) {
20164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20165                 if (r->in.servername) {
20166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20170                 }
20171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20172                 if (r->in.environment) {
20173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20175                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20176                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20177                 }
20178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20180                 if (r->in.buffer) {
20181                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20182                 }
20183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20184         }
20185         if (flags & NDR_OUT) {
20186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20187                 if (r->out.info) {
20188                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20189                 }
20190                 if (r->out.needed == NULL) {
20191                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20192                 }
20193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20194                 if (r->out.count == NULL) {
20195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20196                 }
20197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20198                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20199         }
20200         return NDR_ERR_SUCCESS;
20201 }
20202
20203 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20204 {
20205         uint32_t _ptr_servername;
20206         uint32_t _ptr_environment;
20207         uint32_t _ptr_buffer;
20208         uint32_t _ptr_info;
20209         TALLOC_CTX *_mem_save_servername_0;
20210         TALLOC_CTX *_mem_save_environment_0;
20211         TALLOC_CTX *_mem_save_buffer_0;
20212         TALLOC_CTX *_mem_save_info_0;
20213         TALLOC_CTX *_mem_save_needed_0;
20214         TALLOC_CTX *_mem_save_count_0;
20215         if (flags & NDR_IN) {
20216                 ZERO_STRUCT(r->out);
20217
20218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20219                 if (_ptr_servername) {
20220                         NDR_PULL_ALLOC(ndr, r->in.servername);
20221                 } else {
20222                         r->in.servername = NULL;
20223                 }
20224                 if (r->in.servername) {
20225                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20226                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20228                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20229                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20230                                 return 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));
20231                         }
20232                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20233                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20235                 }
20236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20237                 if (_ptr_environment) {
20238                         NDR_PULL_ALLOC(ndr, r->in.environment);
20239                 } else {
20240                         r->in.environment = NULL;
20241                 }
20242                 if (r->in.environment) {
20243                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20244                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20247                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20248                                 return 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));
20249                         }
20250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20253                 }
20254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20255                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20256                 if (_ptr_buffer) {
20257                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20258                 } else {
20259                         r->in.buffer = NULL;
20260                 }
20261                 if (r->in.buffer) {
20262                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20263                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20264                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20265                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20266                 }
20267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20268                 NDR_PULL_ALLOC(ndr, r->out.needed);
20269                 ZERO_STRUCTP(r->out.needed);
20270                 NDR_PULL_ALLOC(ndr, r->out.count);
20271                 ZERO_STRUCTP(r->out.count);
20272         }
20273         if (flags & NDR_OUT) {
20274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20275                 if (_ptr_info) {
20276                         NDR_PULL_ALLOC(ndr, r->out.info);
20277                 } else {
20278                         r->out.info = NULL;
20279                 }
20280                 if (r->out.info) {
20281                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20282                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20283                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20285                 }
20286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20287                         NDR_PULL_ALLOC(ndr, r->out.needed);
20288                 }
20289                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20290                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20294                         NDR_PULL_ALLOC(ndr, r->out.count);
20295                 }
20296                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20297                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20299                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20301         }
20302         return NDR_ERR_SUCCESS;
20303 }
20304
20305 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20306 {
20307         uint32_t cntr_info_0;
20308         if (flags & NDR_IN) {
20309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20311         }
20312         if (flags & NDR_OUT) {
20313                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20314                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20315                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20316                 }
20317                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20318                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20319                 }
20320         }
20321         return NDR_ERR_SUCCESS;
20322 }
20323
20324 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20325 {
20326         uint32_t cntr_info_0;
20327         TALLOC_CTX *_mem_save_info_0;
20328         if (flags & NDR_IN) {
20329                 ZERO_STRUCT(r->out);
20330
20331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20333         }
20334         if (flags & NDR_OUT) {
20335                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20336                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20337                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20338                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20339                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20340                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20341                 }
20342                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20343                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20344                 }
20345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20346         }
20347         return NDR_ERR_SUCCESS;
20348 }
20349
20350 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20351 {
20352         uint32_t cntr_info_1;
20353         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20354         ndr->depth++;
20355         if (flags & NDR_SET_VALUES) {
20356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20357         }
20358         if (flags & NDR_IN) {
20359                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20360                 ndr->depth++;
20361                 ndr_print_ptr(ndr, "servername", r->in.servername);
20362                 ndr->depth++;
20363                 if (r->in.servername) {
20364                         ndr_print_string(ndr, "servername", r->in.servername);
20365                 }
20366                 ndr->depth--;
20367                 ndr_print_ptr(ndr, "environment", r->in.environment);
20368                 ndr->depth++;
20369                 if (r->in.environment) {
20370                         ndr_print_string(ndr, "environment", r->in.environment);
20371                 }
20372                 ndr->depth--;
20373                 ndr_print_uint32(ndr, "level", r->in.level);
20374                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20375                 ndr->depth++;
20376                 if (r->in.buffer) {
20377                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20378                 }
20379                 ndr->depth--;
20380                 ndr_print_uint32(ndr, "offered", r->in.offered);
20381                 ndr->depth--;
20382         }
20383         if (flags & NDR_OUT) {
20384                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20385                 ndr->depth++;
20386                 ndr_print_ptr(ndr, "count", r->out.count);
20387                 ndr->depth++;
20388                 ndr_print_uint32(ndr, "count", *r->out.count);
20389                 ndr->depth--;
20390                 ndr_print_ptr(ndr, "info", r->out.info);
20391                 ndr->depth++;
20392                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20393                 ndr->depth++;
20394                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
20395                         char *idx_1=NULL;
20396                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
20397                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
20398                                 ndr->depth++;
20399                                 if (r->out.info[cntr_info_1]) {
20400                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
20401                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", r->out.info[cntr_info_1]);
20402                                 }
20403                                 ndr->depth--;
20404                                 free(idx_1);
20405                         }
20406                 }
20407                 ndr->depth--;
20408                 ndr->depth--;
20409                 ndr_print_ptr(ndr, "needed", r->out.needed);
20410                 ndr->depth++;
20411                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20412                 ndr->depth--;
20413                 ndr_print_WERROR(ndr, "result", r->out.result);
20414                 ndr->depth--;
20415         }
20416         ndr->depth--;
20417 }
20418
20419 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20420 {
20421         if (flags & NDR_IN) {
20422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20423                 if (r->in.server) {
20424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20428                 }
20429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20430                 if (r->in.environment) {
20431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20435                 }
20436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20438                 if (r->in.buffer) {
20439                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20440                 }
20441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20442         }
20443         if (flags & NDR_OUT) {
20444                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20445                 if (r->out.info) {
20446                         {
20447                                 struct ndr_push *_ndr_info;
20448                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20449                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20450                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20451                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20452                         }
20453                 }
20454                 if (r->out.needed == NULL) {
20455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20456                 }
20457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20458                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20459         }
20460         return NDR_ERR_SUCCESS;
20461 }
20462
20463 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20464 {
20465         uint32_t _ptr_server;
20466         uint32_t _ptr_environment;
20467         uint32_t _ptr_buffer;
20468         uint32_t _ptr_info;
20469         TALLOC_CTX *_mem_save_server_0;
20470         TALLOC_CTX *_mem_save_environment_0;
20471         TALLOC_CTX *_mem_save_buffer_0;
20472         TALLOC_CTX *_mem_save_info_0;
20473         TALLOC_CTX *_mem_save_needed_0;
20474         if (flags & NDR_IN) {
20475                 ZERO_STRUCT(r->out);
20476
20477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20478                 if (_ptr_server) {
20479                         NDR_PULL_ALLOC(ndr, r->in.server);
20480                 } else {
20481                         r->in.server = NULL;
20482                 }
20483                 if (r->in.server) {
20484                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20485                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20488                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20489                                 return 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));
20490                         }
20491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20494                 }
20495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20496                 if (_ptr_environment) {
20497                         NDR_PULL_ALLOC(ndr, r->in.environment);
20498                 } else {
20499                         r->in.environment = NULL;
20500                 }
20501                 if (r->in.environment) {
20502                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20503                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20504                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20505                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20506                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20507                                 return 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));
20508                         }
20509                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20512                 }
20513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20515                 if (_ptr_buffer) {
20516                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20517                 } else {
20518                         r->in.buffer = NULL;
20519                 }
20520                 if (r->in.buffer) {
20521                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20522                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20523                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20525                 }
20526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20527                 NDR_PULL_ALLOC(ndr, r->out.needed);
20528                 ZERO_STRUCTP(r->out.needed);
20529         }
20530         if (flags & NDR_OUT) {
20531                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20532                 if (_ptr_info) {
20533                         NDR_PULL_ALLOC(ndr, r->out.info);
20534                 } else {
20535                         r->out.info = NULL;
20536                 }
20537                 if (r->out.info) {
20538                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20539                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20540                         {
20541                                 struct ndr_pull *_ndr_info;
20542                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20543                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20544                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20545                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20546                         }
20547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20548                 }
20549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20550                         NDR_PULL_ALLOC(ndr, r->out.needed);
20551                 }
20552                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20557         }
20558         return NDR_ERR_SUCCESS;
20559 }
20560
20561 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20562 {
20563         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20564         ndr->depth++;
20565         if (flags & NDR_SET_VALUES) {
20566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20567         }
20568         if (flags & NDR_IN) {
20569                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20570                 ndr->depth++;
20571                 ndr_print_ptr(ndr, "server", r->in.server);
20572                 ndr->depth++;
20573                 if (r->in.server) {
20574                         ndr_print_string(ndr, "server", r->in.server);
20575                 }
20576                 ndr->depth--;
20577                 ndr_print_ptr(ndr, "environment", r->in.environment);
20578                 ndr->depth++;
20579                 if (r->in.environment) {
20580                         ndr_print_string(ndr, "environment", r->in.environment);
20581                 }
20582                 ndr->depth--;
20583                 ndr_print_uint32(ndr, "level", r->in.level);
20584                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20585                 ndr->depth++;
20586                 if (r->in.buffer) {
20587                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20588                 }
20589                 ndr->depth--;
20590                 ndr_print_uint32(ndr, "offered", r->in.offered);
20591                 ndr->depth--;
20592         }
20593         if (flags & NDR_OUT) {
20594                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20595                 ndr->depth++;
20596                 ndr_print_ptr(ndr, "info", r->out.info);
20597                 ndr->depth++;
20598                 if (r->out.info) {
20599                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20600                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20601                 }
20602                 ndr->depth--;
20603                 ndr_print_ptr(ndr, "needed", r->out.needed);
20604                 ndr->depth++;
20605                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20606                 ndr->depth--;
20607                 ndr_print_WERROR(ndr, "result", r->out.result);
20608                 ndr->depth--;
20609         }
20610         ndr->depth--;
20611 }
20612
20613 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20614 {
20615         if (flags & NDR_IN) {
20616                 if (r->in.handle == NULL) {
20617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20618                 }
20619                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20621                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20622                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20623         }
20624         if (flags & NDR_OUT) {
20625                 if (r->out.job_id == NULL) {
20626                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20627                 }
20628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20629                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20630         }
20631         return NDR_ERR_SUCCESS;
20632 }
20633
20634 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20635 {
20636         TALLOC_CTX *_mem_save_handle_0;
20637         TALLOC_CTX *_mem_save_job_id_0;
20638         if (flags & NDR_IN) {
20639                 ZERO_STRUCT(r->out);
20640
20641                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20642                         NDR_PULL_ALLOC(ndr, r->in.handle);
20643                 }
20644                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20645                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20646                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20647                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20649                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20650                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20651                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20652                 ZERO_STRUCTP(r->out.job_id);
20653         }
20654         if (flags & NDR_OUT) {
20655                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20656                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20657                 }
20658                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20659                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20663         }
20664         return NDR_ERR_SUCCESS;
20665 }
20666
20667 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20668 {
20669         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20670         ndr->depth++;
20671         if (flags & NDR_SET_VALUES) {
20672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20673         }
20674         if (flags & NDR_IN) {
20675                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20676                 ndr->depth++;
20677                 ndr_print_ptr(ndr, "handle", r->in.handle);
20678                 ndr->depth++;
20679                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20680                 ndr->depth--;
20681                 ndr_print_uint32(ndr, "level", r->in.level);
20682                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20683                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20684                 ndr->depth--;
20685         }
20686         if (flags & NDR_OUT) {
20687                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20688                 ndr->depth++;
20689                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20690                 ndr->depth++;
20691                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20692                 ndr->depth--;
20693                 ndr_print_WERROR(ndr, "result", r->out.result);
20694                 ndr->depth--;
20695         }
20696         ndr->depth--;
20697 }
20698
20699 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20700 {
20701         if (flags & NDR_IN) {
20702                 if (r->in.handle == NULL) {
20703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20704                 }
20705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20706         }
20707         if (flags & NDR_OUT) {
20708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20709         }
20710         return NDR_ERR_SUCCESS;
20711 }
20712
20713 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20714 {
20715         TALLOC_CTX *_mem_save_handle_0;
20716         if (flags & NDR_IN) {
20717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20718                         NDR_PULL_ALLOC(ndr, r->in.handle);
20719                 }
20720                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20721                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20722                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20724         }
20725         if (flags & NDR_OUT) {
20726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20727         }
20728         return NDR_ERR_SUCCESS;
20729 }
20730
20731 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
20732 {
20733         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
20734         ndr->depth++;
20735         if (flags & NDR_SET_VALUES) {
20736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20737         }
20738         if (flags & NDR_IN) {
20739                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
20740                 ndr->depth++;
20741                 ndr_print_ptr(ndr, "handle", r->in.handle);
20742                 ndr->depth++;
20743                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20744                 ndr->depth--;
20745                 ndr->depth--;
20746         }
20747         if (flags & NDR_OUT) {
20748                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
20749                 ndr->depth++;
20750                 ndr_print_WERROR(ndr, "result", r->out.result);
20751                 ndr->depth--;
20752         }
20753         ndr->depth--;
20754 }
20755
20756 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
20757 {
20758         if (flags & NDR_IN) {
20759                 if (r->in.handle == NULL) {
20760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20761                 }
20762                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20763                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
20764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
20765         }
20766         if (flags & NDR_OUT) {
20767                 if (r->out.num_written == NULL) {
20768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20769                 }
20770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
20771                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20772         }
20773         return NDR_ERR_SUCCESS;
20774 }
20775
20776 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
20777 {
20778         TALLOC_CTX *_mem_save_handle_0;
20779         TALLOC_CTX *_mem_save_num_written_0;
20780         if (flags & NDR_IN) {
20781                 ZERO_STRUCT(r->out);
20782
20783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20784                         NDR_PULL_ALLOC(ndr, r->in.handle);
20785                 }
20786                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20787                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20788                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20790                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
20791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
20792                 NDR_PULL_ALLOC(ndr, r->out.num_written);
20793                 ZERO_STRUCTP(r->out.num_written);
20794         }
20795         if (flags & NDR_OUT) {
20796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20797                         NDR_PULL_ALLOC(ndr, r->out.num_written);
20798                 }
20799                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
20800                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
20801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
20802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
20803                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20804         }
20805         return NDR_ERR_SUCCESS;
20806 }
20807
20808 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
20809 {
20810         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
20811         ndr->depth++;
20812         if (flags & NDR_SET_VALUES) {
20813                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20814         }
20815         if (flags & NDR_IN) {
20816                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
20817                 ndr->depth++;
20818                 ndr_print_ptr(ndr, "handle", r->in.handle);
20819                 ndr->depth++;
20820                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20821                 ndr->depth--;
20822                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
20823                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
20824                 ndr->depth--;
20825         }
20826         if (flags & NDR_OUT) {
20827                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
20828                 ndr->depth++;
20829                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
20830                 ndr->depth++;
20831                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
20832                 ndr->depth--;
20833                 ndr_print_WERROR(ndr, "result", r->out.result);
20834                 ndr->depth--;
20835         }
20836         ndr->depth--;
20837 }
20838
20839 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
20840 {
20841         if (flags & NDR_IN) {
20842                 if (r->in.handle == NULL) {
20843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20844                 }
20845                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20846         }
20847         if (flags & NDR_OUT) {
20848                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20849         }
20850         return NDR_ERR_SUCCESS;
20851 }
20852
20853 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
20854 {
20855         TALLOC_CTX *_mem_save_handle_0;
20856         if (flags & NDR_IN) {
20857                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20858                         NDR_PULL_ALLOC(ndr, r->in.handle);
20859                 }
20860                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20861                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20862                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20863                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20864         }
20865         if (flags & NDR_OUT) {
20866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20867         }
20868         return NDR_ERR_SUCCESS;
20869 }
20870
20871 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
20872 {
20873         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
20874         ndr->depth++;
20875         if (flags & NDR_SET_VALUES) {
20876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20877         }
20878         if (flags & NDR_IN) {
20879                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
20880                 ndr->depth++;
20881                 ndr_print_ptr(ndr, "handle", r->in.handle);
20882                 ndr->depth++;
20883                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20884                 ndr->depth--;
20885                 ndr->depth--;
20886         }
20887         if (flags & NDR_OUT) {
20888                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
20889                 ndr->depth++;
20890                 ndr_print_WERROR(ndr, "result", r->out.result);
20891                 ndr->depth--;
20892         }
20893         ndr->depth--;
20894 }
20895
20896 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
20897 {
20898         if (flags & NDR_IN) {
20899                 if (r->in.handle == NULL) {
20900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20901                 }
20902                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20903         }
20904         if (flags & NDR_OUT) {
20905                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20906         }
20907         return NDR_ERR_SUCCESS;
20908 }
20909
20910 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
20911 {
20912         TALLOC_CTX *_mem_save_handle_0;
20913         if (flags & NDR_IN) {
20914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20915                         NDR_PULL_ALLOC(ndr, r->in.handle);
20916                 }
20917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20921         }
20922         if (flags & NDR_OUT) {
20923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20924         }
20925         return NDR_ERR_SUCCESS;
20926 }
20927
20928 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
20929 {
20930         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
20931         ndr->depth++;
20932         if (flags & NDR_SET_VALUES) {
20933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20934         }
20935         if (flags & NDR_IN) {
20936                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
20937                 ndr->depth++;
20938                 ndr_print_ptr(ndr, "handle", r->in.handle);
20939                 ndr->depth++;
20940                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20941                 ndr->depth--;
20942                 ndr->depth--;
20943         }
20944         if (flags & NDR_OUT) {
20945                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
20946                 ndr->depth++;
20947                 ndr_print_WERROR(ndr, "result", r->out.result);
20948                 ndr->depth--;
20949         }
20950         ndr->depth--;
20951 }
20952
20953 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
20954 {
20955         if (flags & NDR_IN) {
20956                 if (r->in.handle == NULL) {
20957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20958                 }
20959                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
20961         }
20962         if (flags & NDR_OUT) {
20963                 if (r->out.data == NULL) {
20964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20965                 }
20966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
20967                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
20968                 if (r->out._data_size == NULL) {
20969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20970                 }
20971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
20972                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20973         }
20974         return NDR_ERR_SUCCESS;
20975 }
20976
20977 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
20978 {
20979         TALLOC_CTX *_mem_save_handle_0;
20980         TALLOC_CTX *_mem_save__data_size_0;
20981         if (flags & NDR_IN) {
20982                 ZERO_STRUCT(r->out);
20983
20984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20985                         NDR_PULL_ALLOC(ndr, r->in.handle);
20986                 }
20987                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
20992                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
20993                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
20994                 NDR_PULL_ALLOC(ndr, r->out._data_size);
20995                 ZERO_STRUCTP(r->out._data_size);
20996         }
20997         if (flags & NDR_OUT) {
20998                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
20999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21000                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21001                 }
21002                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21004                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21005                 }
21006                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21007                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21011                 if (r->out.data) {
21012                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21013                 }
21014         }
21015         return NDR_ERR_SUCCESS;
21016 }
21017
21018 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21019 {
21020         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21021         ndr->depth++;
21022         if (flags & NDR_SET_VALUES) {
21023                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21024         }
21025         if (flags & NDR_IN) {
21026                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21027                 ndr->depth++;
21028                 ndr_print_ptr(ndr, "handle", r->in.handle);
21029                 ndr->depth++;
21030                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21031                 ndr->depth--;
21032                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21033                 ndr->depth--;
21034         }
21035         if (flags & NDR_OUT) {
21036                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21037                 ndr->depth++;
21038                 ndr_print_ptr(ndr, "data", r->out.data);
21039                 ndr->depth++;
21040                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21041                 ndr->depth--;
21042                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21043                 ndr->depth++;
21044                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21045                 ndr->depth--;
21046                 ndr_print_WERROR(ndr, "result", r->out.result);
21047                 ndr->depth--;
21048         }
21049         ndr->depth--;
21050 }
21051
21052 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21053 {
21054         if (flags & NDR_IN) {
21055                 if (r->in.handle == NULL) {
21056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21057                 }
21058                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21059         }
21060         if (flags & NDR_OUT) {
21061                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21062         }
21063         return NDR_ERR_SUCCESS;
21064 }
21065
21066 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21067 {
21068         TALLOC_CTX *_mem_save_handle_0;
21069         if (flags & NDR_IN) {
21070                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21071                         NDR_PULL_ALLOC(ndr, r->in.handle);
21072                 }
21073                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21074                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21075                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21076                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21077         }
21078         if (flags & NDR_OUT) {
21079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21080         }
21081         return NDR_ERR_SUCCESS;
21082 }
21083
21084 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21085 {
21086         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21087         ndr->depth++;
21088         if (flags & NDR_SET_VALUES) {
21089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21090         }
21091         if (flags & NDR_IN) {
21092                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21093                 ndr->depth++;
21094                 ndr_print_ptr(ndr, "handle", r->in.handle);
21095                 ndr->depth++;
21096                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21097                 ndr->depth--;
21098                 ndr->depth--;
21099         }
21100         if (flags & NDR_OUT) {
21101                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21102                 ndr->depth++;
21103                 ndr_print_WERROR(ndr, "result", r->out.result);
21104                 ndr->depth--;
21105         }
21106         ndr->depth--;
21107 }
21108
21109 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21110 {
21111         if (flags & NDR_IN) {
21112                 if (r->in.handle == NULL) {
21113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21114                 }
21115                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21118                 if (r->in.buffer) {
21119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21120                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21121                 }
21122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21123         }
21124         if (flags & NDR_OUT) {
21125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21126                 if (r->out.buffer) {
21127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21128                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21129                 }
21130                 if (r->out.needed == NULL) {
21131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21132                 }
21133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21134                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21135         }
21136         return NDR_ERR_SUCCESS;
21137 }
21138
21139 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21140 {
21141         uint32_t _ptr_buffer;
21142         TALLOC_CTX *_mem_save_handle_0;
21143         TALLOC_CTX *_mem_save_buffer_0;
21144         TALLOC_CTX *_mem_save_needed_0;
21145         if (flags & NDR_IN) {
21146                 ZERO_STRUCT(r->out);
21147
21148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21149                         NDR_PULL_ALLOC(ndr, r->in.handle);
21150                 }
21151                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21152                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21153                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21157                 if (_ptr_buffer) {
21158                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21159                 } else {
21160                         r->in.buffer = NULL;
21161                 }
21162                 if (r->in.buffer) {
21163                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21164                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21166                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21167                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21169                 }
21170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21171                 NDR_PULL_ALLOC(ndr, r->out.needed);
21172                 ZERO_STRUCTP(r->out.needed);
21173                 if (r->in.buffer) {
21174                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21175                 }
21176         }
21177         if (flags & NDR_OUT) {
21178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21179                 if (_ptr_buffer) {
21180                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21181                 } else {
21182                         r->out.buffer = NULL;
21183                 }
21184                 if (r->out.buffer) {
21185                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21186                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21188                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21189                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21190                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21191                 }
21192                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21193                         NDR_PULL_ALLOC(ndr, r->out.needed);
21194                 }
21195                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21196                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21198                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21200                 if (r->out.buffer) {
21201                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21202                 }
21203         }
21204         return NDR_ERR_SUCCESS;
21205 }
21206
21207 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21208 {
21209         ndr_print_struct(ndr, name, "spoolss_AddJob");
21210         ndr->depth++;
21211         if (flags & NDR_SET_VALUES) {
21212                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21213         }
21214         if (flags & NDR_IN) {
21215                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21216                 ndr->depth++;
21217                 ndr_print_ptr(ndr, "handle", r->in.handle);
21218                 ndr->depth++;
21219                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21220                 ndr->depth--;
21221                 ndr_print_uint32(ndr, "level", r->in.level);
21222                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21223                 ndr->depth++;
21224                 if (r->in.buffer) {
21225                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21226                 }
21227                 ndr->depth--;
21228                 ndr_print_uint32(ndr, "offered", r->in.offered);
21229                 ndr->depth--;
21230         }
21231         if (flags & NDR_OUT) {
21232                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21233                 ndr->depth++;
21234                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21235                 ndr->depth++;
21236                 if (r->out.buffer) {
21237                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21238                 }
21239                 ndr->depth--;
21240                 ndr_print_ptr(ndr, "needed", r->out.needed);
21241                 ndr->depth++;
21242                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21243                 ndr->depth--;
21244                 ndr_print_WERROR(ndr, "result", r->out.result);
21245                 ndr->depth--;
21246         }
21247         ndr->depth--;
21248 }
21249
21250 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21251 {
21252         if (flags & NDR_IN) {
21253                 if (r->in.handle == NULL) {
21254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21255                 }
21256                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21258         }
21259         if (flags & NDR_OUT) {
21260                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21261         }
21262         return NDR_ERR_SUCCESS;
21263 }
21264
21265 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21266 {
21267         TALLOC_CTX *_mem_save_handle_0;
21268         if (flags & NDR_IN) {
21269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21270                         NDR_PULL_ALLOC(ndr, r->in.handle);
21271                 }
21272                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21273                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21274                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21277         }
21278         if (flags & NDR_OUT) {
21279                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21280         }
21281         return NDR_ERR_SUCCESS;
21282 }
21283
21284 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21285 {
21286         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21287         ndr->depth++;
21288         if (flags & NDR_SET_VALUES) {
21289                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21290         }
21291         if (flags & NDR_IN) {
21292                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21293                 ndr->depth++;
21294                 ndr_print_ptr(ndr, "handle", r->in.handle);
21295                 ndr->depth++;
21296                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21297                 ndr->depth--;
21298                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21299                 ndr->depth--;
21300         }
21301         if (flags & NDR_OUT) {
21302                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21303                 ndr->depth++;
21304                 ndr_print_WERROR(ndr, "result", r->out.result);
21305                 ndr->depth--;
21306         }
21307         ndr->depth--;
21308 }
21309
21310 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21311 {
21312         if (flags & NDR_IN) {
21313                 if (r->in.handle == NULL) {
21314                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21315                 }
21316                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21320                 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));
21321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21322         }
21323         if (flags & NDR_OUT) {
21324                 if (r->out.type == NULL) {
21325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21326                 }
21327                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
21328                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21329                 if (r->out.needed == NULL) {
21330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21331                 }
21332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21334         }
21335         return NDR_ERR_SUCCESS;
21336 }
21337
21338 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21339 {
21340         TALLOC_CTX *_mem_save_handle_0;
21341         TALLOC_CTX *_mem_save_type_0;
21342         TALLOC_CTX *_mem_save_needed_0;
21343         if (flags & NDR_IN) {
21344                 ZERO_STRUCT(r->out);
21345
21346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21347                         NDR_PULL_ALLOC(ndr, r->in.handle);
21348                 }
21349                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21350                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21351                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21353                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21354                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21355                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21356                         return 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));
21357                 }
21358                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21359                 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));
21360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21361                 NDR_PULL_ALLOC(ndr, r->out.type);
21362                 ZERO_STRUCTP(r->out.type);
21363                 NDR_PULL_ALLOC(ndr, r->out.needed);
21364                 ZERO_STRUCTP(r->out.needed);
21365         }
21366         if (flags & NDR_OUT) {
21367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21368                         NDR_PULL_ALLOC(ndr, r->out.type);
21369                 }
21370                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21371                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21372                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
21373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21374                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
21375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21376                         NDR_PULL_ALLOC(ndr, r->out.needed);
21377                 }
21378                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21379                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21382                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21383         }
21384         return NDR_ERR_SUCCESS;
21385 }
21386
21387 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21388 {
21389         if (flags & NDR_IN) {
21390                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21391         }
21392         if (flags & NDR_OUT) {
21393                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21394                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21395         }
21396         return NDR_ERR_SUCCESS;
21397 }
21398
21399 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21400 {
21401         if (flags & NDR_IN) {
21402                 ZERO_STRUCT(r->out);
21403
21404                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21405         }
21406         if (flags & NDR_OUT) {
21407                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
21408                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21409         }
21410         return NDR_ERR_SUCCESS;
21411 }
21412
21413 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21414 {
21415         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21416         ndr->depth++;
21417         if (flags & NDR_SET_VALUES) {
21418                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21419         }
21420         if (flags & NDR_IN) {
21421                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21422                 ndr->depth++;
21423                 ndr_print_ptr(ndr, "handle", r->in.handle);
21424                 ndr->depth++;
21425                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21426                 ndr->depth--;
21427                 ndr_print_string(ndr, "value_name", r->in.value_name);
21428                 ndr_print_uint32(ndr, "offered", r->in.offered);
21429                 ndr->depth--;
21430         }
21431         if (flags & NDR_OUT) {
21432                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21433                 ndr->depth++;
21434                 ndr_print_ptr(ndr, "type", r->out.type);
21435                 ndr->depth++;
21436                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
21437                 ndr->depth--;
21438                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
21439                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
21440                 ndr_print_ptr(ndr, "needed", r->out.needed);
21441                 ndr->depth++;
21442                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21443                 ndr->depth--;
21444                 ndr_print_WERROR(ndr, "result", r->out.result);
21445                 ndr->depth--;
21446         }
21447         ndr->depth--;
21448 }
21449
21450 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21451 {
21452         if (flags & NDR_IN) {
21453                 if (r->in.handle == NULL) {
21454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21455                 }
21456                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21460                 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));
21461                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21462                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21464         }
21465         if (flags & NDR_OUT) {
21466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21467         }
21468         return NDR_ERR_SUCCESS;
21469 }
21470
21471 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21472 {
21473         if (flags & NDR_IN) {
21474                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21475         }
21476         if (flags & NDR_OUT) {
21477                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21478                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21479         }
21480         return NDR_ERR_SUCCESS;
21481 }
21482
21483 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21484 {
21485         TALLOC_CTX *_mem_save_handle_0;
21486         if (flags & NDR_IN) {
21487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21488                         NDR_PULL_ALLOC(ndr, r->in.handle);
21489                 }
21490                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21494                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21495                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21496                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21497                         return 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));
21498                 }
21499                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21500                 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));
21501                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21502                 {
21503                         struct ndr_pull *_ndr_data;
21504                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21505                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21506                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21507                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21508                 }
21509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21510         }
21511         if (flags & NDR_OUT) {
21512                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21513         }
21514         return NDR_ERR_SUCCESS;
21515 }
21516
21517 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21518 {
21519         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21520         ndr->depth++;
21521         if (flags & NDR_SET_VALUES) {
21522                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21523         }
21524         if (flags & NDR_IN) {
21525                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21526                 ndr->depth++;
21527                 ndr_print_ptr(ndr, "handle", r->in.handle);
21528                 ndr->depth++;
21529                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21530                 ndr->depth--;
21531                 ndr_print_string(ndr, "value_name", r->in.value_name);
21532                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
21533                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21534                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21535                 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);
21536                 ndr->depth--;
21537         }
21538         if (flags & NDR_OUT) {
21539                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21540                 ndr->depth++;
21541                 ndr_print_WERROR(ndr, "result", r->out.result);
21542                 ndr->depth--;
21543         }
21544         ndr->depth--;
21545 }
21546
21547 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21548 {
21549         if (flags & NDR_IN) {
21550         }
21551         if (flags & NDR_OUT) {
21552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21553         }
21554         return NDR_ERR_SUCCESS;
21555 }
21556
21557 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21558 {
21559         if (flags & NDR_IN) {
21560         }
21561         if (flags & NDR_OUT) {
21562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21563         }
21564         return NDR_ERR_SUCCESS;
21565 }
21566
21567 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21568 {
21569         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21570         ndr->depth++;
21571         if (flags & NDR_SET_VALUES) {
21572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21573         }
21574         if (flags & NDR_IN) {
21575                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21576                 ndr->depth++;
21577                 ndr->depth--;
21578         }
21579         if (flags & NDR_OUT) {
21580                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21581                 ndr->depth++;
21582                 ndr_print_WERROR(ndr, "result", r->out.result);
21583                 ndr->depth--;
21584         }
21585         ndr->depth--;
21586 }
21587
21588 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21589 {
21590         if (flags & NDR_IN) {
21591                 if (r->in.handle == NULL) {
21592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21593                 }
21594                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21595         }
21596         if (flags & NDR_OUT) {
21597                 if (r->out.handle == NULL) {
21598                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21599                 }
21600                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21601                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21602         }
21603         return NDR_ERR_SUCCESS;
21604 }
21605
21606 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21607 {
21608         TALLOC_CTX *_mem_save_handle_0;
21609         if (flags & NDR_IN) {
21610                 ZERO_STRUCT(r->out);
21611
21612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21613                         NDR_PULL_ALLOC(ndr, r->in.handle);
21614                 }
21615                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21616                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21617                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21619                 NDR_PULL_ALLOC(ndr, r->out.handle);
21620                 *r->out.handle = *r->in.handle;
21621         }
21622         if (flags & NDR_OUT) {
21623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21624                         NDR_PULL_ALLOC(ndr, r->out.handle);
21625                 }
21626                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21627                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21628                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21631         }
21632         return NDR_ERR_SUCCESS;
21633 }
21634
21635 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21636 {
21637         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21638         ndr->depth++;
21639         if (flags & NDR_SET_VALUES) {
21640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21641         }
21642         if (flags & NDR_IN) {
21643                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21644                 ndr->depth++;
21645                 ndr_print_ptr(ndr, "handle", r->in.handle);
21646                 ndr->depth++;
21647                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21648                 ndr->depth--;
21649                 ndr->depth--;
21650         }
21651         if (flags & NDR_OUT) {
21652                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21653                 ndr->depth++;
21654                 ndr_print_ptr(ndr, "handle", r->out.handle);
21655                 ndr->depth++;
21656                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21657                 ndr->depth--;
21658                 ndr_print_WERROR(ndr, "result", r->out.result);
21659                 ndr->depth--;
21660         }
21661         ndr->depth--;
21662 }
21663
21664 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21665 {
21666         if (flags & NDR_IN) {
21667                 if (r->in.handle == NULL) {
21668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21669                 }
21670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21672                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21673                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21674         }
21675         if (flags & NDR_OUT) {
21676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21677         }
21678         return NDR_ERR_SUCCESS;
21679 }
21680
21681 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21682 {
21683         TALLOC_CTX *_mem_save_handle_0;
21684         if (flags & NDR_IN) {
21685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21686                         NDR_PULL_ALLOC(ndr, r->in.handle);
21687                 }
21688                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21693                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21694                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21695         }
21696         if (flags & NDR_OUT) {
21697                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21698         }
21699         return NDR_ERR_SUCCESS;
21700 }
21701
21702 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21703 {
21704         ndr_print_struct(ndr, name, "spoolss_AddForm");
21705         ndr->depth++;
21706         if (flags & NDR_SET_VALUES) {
21707                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21708         }
21709         if (flags & NDR_IN) {
21710                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21711                 ndr->depth++;
21712                 ndr_print_ptr(ndr, "handle", r->in.handle);
21713                 ndr->depth++;
21714                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21715                 ndr->depth--;
21716                 ndr_print_uint32(ndr, "level", r->in.level);
21717                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21718                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
21719                 ndr->depth--;
21720         }
21721         if (flags & NDR_OUT) {
21722                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
21723                 ndr->depth++;
21724                 ndr_print_WERROR(ndr, "result", r->out.result);
21725                 ndr->depth--;
21726         }
21727         ndr->depth--;
21728 }
21729
21730 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
21731 {
21732         if (flags & NDR_IN) {
21733                 if (r->in.handle == NULL) {
21734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21735                 }
21736                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21740                 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));
21741         }
21742         if (flags & NDR_OUT) {
21743                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21744         }
21745         return NDR_ERR_SUCCESS;
21746 }
21747
21748 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
21749 {
21750         TALLOC_CTX *_mem_save_handle_0;
21751         if (flags & NDR_IN) {
21752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21753                         NDR_PULL_ALLOC(ndr, r->in.handle);
21754                 }
21755                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21756                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21757                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21759                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
21760                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
21761                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
21762                         return 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));
21763                 }
21764                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
21765                 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));
21766         }
21767         if (flags & NDR_OUT) {
21768                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21769         }
21770         return NDR_ERR_SUCCESS;
21771 }
21772
21773 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
21774 {
21775         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
21776         ndr->depth++;
21777         if (flags & NDR_SET_VALUES) {
21778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21779         }
21780         if (flags & NDR_IN) {
21781                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
21782                 ndr->depth++;
21783                 ndr_print_ptr(ndr, "handle", r->in.handle);
21784                 ndr->depth++;
21785                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21786                 ndr->depth--;
21787                 ndr_print_string(ndr, "form_name", r->in.form_name);
21788                 ndr->depth--;
21789         }
21790         if (flags & NDR_OUT) {
21791                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
21792                 ndr->depth++;
21793                 ndr_print_WERROR(ndr, "result", r->out.result);
21794                 ndr->depth--;
21795         }
21796         ndr->depth--;
21797 }
21798
21799 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *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                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21809                 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));
21810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21812                 if (r->in.buffer) {
21813                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21814                 }
21815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21816         }
21817         if (flags & NDR_OUT) {
21818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21819                 if (r->out.info) {
21820                         {
21821                                 struct ndr_push *_ndr_info;
21822                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21823                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21824                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21825                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21826                         }
21827                 }
21828                 if (r->out.needed == NULL) {
21829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21830                 }
21831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21833         }
21834         return NDR_ERR_SUCCESS;
21835 }
21836
21837 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
21838 {
21839         uint32_t _ptr_buffer;
21840         uint32_t _ptr_info;
21841         TALLOC_CTX *_mem_save_handle_0;
21842         TALLOC_CTX *_mem_save_buffer_0;
21843         TALLOC_CTX *_mem_save_info_0;
21844         TALLOC_CTX *_mem_save_needed_0;
21845         if (flags & NDR_IN) {
21846                 ZERO_STRUCT(r->out);
21847
21848                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21849                         NDR_PULL_ALLOC(ndr, r->in.handle);
21850                 }
21851                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21852                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21853                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21855                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
21856                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
21857                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
21858                         return 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));
21859                 }
21860                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
21861                 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));
21862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21863                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21864                 if (_ptr_buffer) {
21865                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21866                 } else {
21867                         r->in.buffer = NULL;
21868                 }
21869                 if (r->in.buffer) {
21870                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21871                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21872                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21874                 }
21875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21876                 NDR_PULL_ALLOC(ndr, r->out.needed);
21877                 ZERO_STRUCTP(r->out.needed);
21878         }
21879         if (flags & NDR_OUT) {
21880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21881                 if (_ptr_info) {
21882                         NDR_PULL_ALLOC(ndr, r->out.info);
21883                 } else {
21884                         r->out.info = NULL;
21885                 }
21886                 if (r->out.info) {
21887                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21888                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21889                         {
21890                                 struct ndr_pull *_ndr_info;
21891                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21892                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21893                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21894                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21895                         }
21896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21897                 }
21898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21899                         NDR_PULL_ALLOC(ndr, r->out.needed);
21900                 }
21901                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21902                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21906         }
21907         return NDR_ERR_SUCCESS;
21908 }
21909
21910 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
21911 {
21912         ndr_print_struct(ndr, name, "spoolss_GetForm");
21913         ndr->depth++;
21914         if (flags & NDR_SET_VALUES) {
21915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21916         }
21917         if (flags & NDR_IN) {
21918                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
21919                 ndr->depth++;
21920                 ndr_print_ptr(ndr, "handle", r->in.handle);
21921                 ndr->depth++;
21922                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21923                 ndr->depth--;
21924                 ndr_print_string(ndr, "form_name", r->in.form_name);
21925                 ndr_print_uint32(ndr, "level", r->in.level);
21926                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21927                 ndr->depth++;
21928                 if (r->in.buffer) {
21929                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21930                 }
21931                 ndr->depth--;
21932                 ndr_print_uint32(ndr, "offered", r->in.offered);
21933                 ndr->depth--;
21934         }
21935         if (flags & NDR_OUT) {
21936                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
21937                 ndr->depth++;
21938                 ndr_print_ptr(ndr, "info", r->out.info);
21939                 ndr->depth++;
21940                 if (r->out.info) {
21941                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21942                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
21943                 }
21944                 ndr->depth--;
21945                 ndr_print_ptr(ndr, "needed", r->out.needed);
21946                 ndr->depth++;
21947                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21948                 ndr->depth--;
21949                 ndr_print_WERROR(ndr, "result", r->out.result);
21950                 ndr->depth--;
21951         }
21952         ndr->depth--;
21953 }
21954
21955 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
21956 {
21957         if (flags & NDR_IN) {
21958                 if (r->in.handle == NULL) {
21959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21960                 }
21961                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21965                 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));
21966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21967                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21968                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21969         }
21970         if (flags & NDR_OUT) {
21971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21972         }
21973         return NDR_ERR_SUCCESS;
21974 }
21975
21976 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
21977 {
21978         TALLOC_CTX *_mem_save_handle_0;
21979         if (flags & NDR_IN) {
21980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21981                         NDR_PULL_ALLOC(ndr, r->in.handle);
21982                 }
21983                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21984                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21985                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21987                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
21988                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
21989                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
21990                         return 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));
21991                 }
21992                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
21993                 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));
21994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21995                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21996                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21997         }
21998         if (flags & NDR_OUT) {
21999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22000         }
22001         return NDR_ERR_SUCCESS;
22002 }
22003
22004 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22005 {
22006         ndr_print_struct(ndr, name, "spoolss_SetForm");
22007         ndr->depth++;
22008         if (flags & NDR_SET_VALUES) {
22009                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22010         }
22011         if (flags & NDR_IN) {
22012                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22013                 ndr->depth++;
22014                 ndr_print_ptr(ndr, "handle", r->in.handle);
22015                 ndr->depth++;
22016                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22017                 ndr->depth--;
22018                 ndr_print_string(ndr, "form_name", r->in.form_name);
22019                 ndr_print_uint32(ndr, "level", r->in.level);
22020                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22021                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22022                 ndr->depth--;
22023         }
22024         if (flags & NDR_OUT) {
22025                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22026                 ndr->depth++;
22027                 ndr_print_WERROR(ndr, "result", r->out.result);
22028                 ndr->depth--;
22029         }
22030         ndr->depth--;
22031 }
22032
22033 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22034 {
22035         if (flags & NDR_IN) {
22036                 if (r->in.handle == NULL) {
22037                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22038                 }
22039                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22042                 if (r->in.buffer) {
22043                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22044                 }
22045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22046         }
22047         if (flags & NDR_OUT) {
22048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22049                 if (r->out.info) {
22050                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22051                 }
22052                 if (r->out.needed == NULL) {
22053                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22054                 }
22055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22056                 if (r->out.count == NULL) {
22057                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22058                 }
22059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22060                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22061         }
22062         return NDR_ERR_SUCCESS;
22063 }
22064
22065 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22066 {
22067         uint32_t _ptr_buffer;
22068         uint32_t _ptr_info;
22069         TALLOC_CTX *_mem_save_handle_0;
22070         TALLOC_CTX *_mem_save_buffer_0;
22071         TALLOC_CTX *_mem_save_info_0;
22072         TALLOC_CTX *_mem_save_needed_0;
22073         TALLOC_CTX *_mem_save_count_0;
22074         if (flags & NDR_IN) {
22075                 ZERO_STRUCT(r->out);
22076
22077                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22078                         NDR_PULL_ALLOC(ndr, r->in.handle);
22079                 }
22080                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22081                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22082                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22083                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22086                 if (_ptr_buffer) {
22087                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22088                 } else {
22089                         r->in.buffer = NULL;
22090                 }
22091                 if (r->in.buffer) {
22092                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22093                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22094                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22096                 }
22097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22098                 NDR_PULL_ALLOC(ndr, r->out.needed);
22099                 ZERO_STRUCTP(r->out.needed);
22100                 NDR_PULL_ALLOC(ndr, r->out.count);
22101                 ZERO_STRUCTP(r->out.count);
22102         }
22103         if (flags & NDR_OUT) {
22104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22105                 if (_ptr_info) {
22106                         NDR_PULL_ALLOC(ndr, r->out.info);
22107                 } else {
22108                         r->out.info = NULL;
22109                 }
22110                 if (r->out.info) {
22111                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22112                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22113                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22115                 }
22116                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22117                         NDR_PULL_ALLOC(ndr, r->out.needed);
22118                 }
22119                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22120                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22122                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22124                         NDR_PULL_ALLOC(ndr, r->out.count);
22125                 }
22126                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22127                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22130                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22131         }
22132         return NDR_ERR_SUCCESS;
22133 }
22134
22135 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22136 {
22137         uint32_t cntr_info_0;
22138         if (flags & NDR_IN) {
22139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22141         }
22142         if (flags & NDR_OUT) {
22143                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22144                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22145                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22146                 }
22147                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22148                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22149                 }
22150         }
22151         return NDR_ERR_SUCCESS;
22152 }
22153
22154 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22155 {
22156         uint32_t cntr_info_0;
22157         TALLOC_CTX *_mem_save_info_0;
22158         if (flags & NDR_IN) {
22159                 ZERO_STRUCT(r->out);
22160
22161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22163         }
22164         if (flags & NDR_OUT) {
22165                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22166                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22167                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22168                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22169                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22170                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22171                 }
22172                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22173                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22174                 }
22175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22176         }
22177         return NDR_ERR_SUCCESS;
22178 }
22179
22180 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22181 {
22182         uint32_t cntr_info_1;
22183         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22184         ndr->depth++;
22185         if (flags & NDR_SET_VALUES) {
22186                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22187         }
22188         if (flags & NDR_IN) {
22189                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22190                 ndr->depth++;
22191                 ndr_print_ptr(ndr, "handle", r->in.handle);
22192                 ndr->depth++;
22193                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22194                 ndr->depth--;
22195                 ndr_print_uint32(ndr, "level", r->in.level);
22196                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22197                 ndr->depth++;
22198                 if (r->in.buffer) {
22199                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22200                 }
22201                 ndr->depth--;
22202                 ndr_print_uint32(ndr, "offered", r->in.offered);
22203                 ndr->depth--;
22204         }
22205         if (flags & NDR_OUT) {
22206                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22207                 ndr->depth++;
22208                 ndr_print_ptr(ndr, "count", r->out.count);
22209                 ndr->depth++;
22210                 ndr_print_uint32(ndr, "count", *r->out.count);
22211                 ndr->depth--;
22212                 ndr_print_ptr(ndr, "info", r->out.info);
22213                 ndr->depth++;
22214                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22215                 ndr->depth++;
22216                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
22217                         char *idx_1=NULL;
22218                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
22219                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
22220                                 ndr->depth++;
22221                                 if (r->out.info[cntr_info_1]) {
22222                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
22223                                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info[cntr_info_1]);
22224                                 }
22225                                 ndr->depth--;
22226                                 free(idx_1);
22227                         }
22228                 }
22229                 ndr->depth--;
22230                 ndr->depth--;
22231                 ndr_print_ptr(ndr, "needed", r->out.needed);
22232                 ndr->depth++;
22233                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22234                 ndr->depth--;
22235                 ndr_print_WERROR(ndr, "result", r->out.result);
22236                 ndr->depth--;
22237         }
22238         ndr->depth--;
22239 }
22240
22241 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22242 {
22243         if (flags & NDR_IN) {
22244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22245                 if (r->in.servername) {
22246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22250                 }
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_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22277 {
22278         uint32_t _ptr_servername;
22279         uint32_t _ptr_buffer;
22280         uint32_t _ptr_info;
22281         TALLOC_CTX *_mem_save_servername_0;
22282         TALLOC_CTX *_mem_save_buffer_0;
22283         TALLOC_CTX *_mem_save_info_0;
22284         TALLOC_CTX *_mem_save_needed_0;
22285         TALLOC_CTX *_mem_save_count_0;
22286         if (flags & NDR_IN) {
22287                 ZERO_STRUCT(r->out);
22288
22289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22290                 if (_ptr_servername) {
22291                         NDR_PULL_ALLOC(ndr, r->in.servername);
22292                 } else {
22293                         r->in.servername = NULL;
22294                 }
22295                 if (r->in.servername) {
22296                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22297                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22298                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22299                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22300                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22301                                 return 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));
22302                         }
22303                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22304                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22306                 }
22307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22309                 if (_ptr_buffer) {
22310                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22311                 } else {
22312                         r->in.buffer = NULL;
22313                 }
22314                 if (r->in.buffer) {
22315                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22316                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22317                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22319                 }
22320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22321                 NDR_PULL_ALLOC(ndr, r->out.needed);
22322                 ZERO_STRUCTP(r->out.needed);
22323                 NDR_PULL_ALLOC(ndr, r->out.count);
22324                 ZERO_STRUCTP(r->out.count);
22325         }
22326         if (flags & NDR_OUT) {
22327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22328                 if (_ptr_info) {
22329                         NDR_PULL_ALLOC(ndr, r->out.info);
22330                 } else {
22331                         r->out.info = NULL;
22332                 }
22333                 if (r->out.info) {
22334                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22335                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22336                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22338                 }
22339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22340                         NDR_PULL_ALLOC(ndr, r->out.needed);
22341                 }
22342                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22343                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22347                         NDR_PULL_ALLOC(ndr, r->out.count);
22348                 }
22349                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22350                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22353                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22354         }
22355         return NDR_ERR_SUCCESS;
22356 }
22357
22358 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22359 {
22360         uint32_t cntr_info_0;
22361         if (flags & NDR_IN) {
22362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22364         }
22365         if (flags & NDR_OUT) {
22366                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22367                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22368                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22369                 }
22370                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22371                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22372                 }
22373         }
22374         return NDR_ERR_SUCCESS;
22375 }
22376
22377 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22378 {
22379         uint32_t cntr_info_0;
22380         TALLOC_CTX *_mem_save_info_0;
22381         if (flags & NDR_IN) {
22382                 ZERO_STRUCT(r->out);
22383
22384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22386         }
22387         if (flags & NDR_OUT) {
22388                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22389                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22390                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22391                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22392                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22393                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22394                 }
22395                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22396                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22397                 }
22398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22399         }
22400         return NDR_ERR_SUCCESS;
22401 }
22402
22403 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22404 {
22405         uint32_t cntr_info_1;
22406         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22407         ndr->depth++;
22408         if (flags & NDR_SET_VALUES) {
22409                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22410         }
22411         if (flags & NDR_IN) {
22412                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22413                 ndr->depth++;
22414                 ndr_print_ptr(ndr, "servername", r->in.servername);
22415                 ndr->depth++;
22416                 if (r->in.servername) {
22417                         ndr_print_string(ndr, "servername", r->in.servername);
22418                 }
22419                 ndr->depth--;
22420                 ndr_print_uint32(ndr, "level", r->in.level);
22421                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22422                 ndr->depth++;
22423                 if (r->in.buffer) {
22424                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22425                 }
22426                 ndr->depth--;
22427                 ndr_print_uint32(ndr, "offered", r->in.offered);
22428                 ndr->depth--;
22429         }
22430         if (flags & NDR_OUT) {
22431                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22432                 ndr->depth++;
22433                 ndr_print_ptr(ndr, "count", r->out.count);
22434                 ndr->depth++;
22435                 ndr_print_uint32(ndr, "count", *r->out.count);
22436                 ndr->depth--;
22437                 ndr_print_ptr(ndr, "info", r->out.info);
22438                 ndr->depth++;
22439                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22440                 ndr->depth++;
22441                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
22442                         char *idx_1=NULL;
22443                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
22444                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
22445                                 ndr->depth++;
22446                                 if (r->out.info[cntr_info_1]) {
22447                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
22448                                         ndr_print_spoolss_PortInfo(ndr, "info", r->out.info[cntr_info_1]);
22449                                 }
22450                                 ndr->depth--;
22451                                 free(idx_1);
22452                         }
22453                 }
22454                 ndr->depth--;
22455                 ndr->depth--;
22456                 ndr_print_ptr(ndr, "needed", r->out.needed);
22457                 ndr->depth++;
22458                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22459                 ndr->depth--;
22460                 ndr_print_WERROR(ndr, "result", r->out.result);
22461                 ndr->depth--;
22462         }
22463         ndr->depth--;
22464 }
22465
22466 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22467 {
22468         if (flags & NDR_IN) {
22469                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22470                 if (r->in.servername) {
22471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22474                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22475                 }
22476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22478                 if (r->in.buffer) {
22479                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22480                 }
22481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22482         }
22483         if (flags & NDR_OUT) {
22484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22485                 if (r->out.info) {
22486                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22487                 }
22488                 if (r->out.needed == NULL) {
22489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22490                 }
22491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22492                 if (r->out.count == NULL) {
22493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22494                 }
22495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22497         }
22498         return NDR_ERR_SUCCESS;
22499 }
22500
22501 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22502 {
22503         uint32_t _ptr_servername;
22504         uint32_t _ptr_buffer;
22505         uint32_t _ptr_info;
22506         TALLOC_CTX *_mem_save_servername_0;
22507         TALLOC_CTX *_mem_save_buffer_0;
22508         TALLOC_CTX *_mem_save_info_0;
22509         TALLOC_CTX *_mem_save_needed_0;
22510         TALLOC_CTX *_mem_save_count_0;
22511         if (flags & NDR_IN) {
22512                 ZERO_STRUCT(r->out);
22513
22514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22515                 if (_ptr_servername) {
22516                         NDR_PULL_ALLOC(ndr, r->in.servername);
22517                 } else {
22518                         r->in.servername = NULL;
22519                 }
22520                 if (r->in.servername) {
22521                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22522                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22525                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22526                                 return 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));
22527                         }
22528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22531                 }
22532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22534                 if (_ptr_buffer) {
22535                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22536                 } else {
22537                         r->in.buffer = NULL;
22538                 }
22539                 if (r->in.buffer) {
22540                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22541                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22542                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22544                 }
22545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22546                 NDR_PULL_ALLOC(ndr, r->out.needed);
22547                 ZERO_STRUCTP(r->out.needed);
22548                 NDR_PULL_ALLOC(ndr, r->out.count);
22549                 ZERO_STRUCTP(r->out.count);
22550         }
22551         if (flags & NDR_OUT) {
22552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22553                 if (_ptr_info) {
22554                         NDR_PULL_ALLOC(ndr, r->out.info);
22555                 } else {
22556                         r->out.info = NULL;
22557                 }
22558                 if (r->out.info) {
22559                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22560                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22561                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22563                 }
22564                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22565                         NDR_PULL_ALLOC(ndr, r->out.needed);
22566                 }
22567                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22568                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22570                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22572                         NDR_PULL_ALLOC(ndr, r->out.count);
22573                 }
22574                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22578                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22579         }
22580         return NDR_ERR_SUCCESS;
22581 }
22582
22583 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22584 {
22585         uint32_t cntr_info_0;
22586         if (flags & NDR_IN) {
22587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22589         }
22590         if (flags & NDR_OUT) {
22591                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22592                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22593                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22594                 }
22595                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22596                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22597                 }
22598         }
22599         return NDR_ERR_SUCCESS;
22600 }
22601
22602 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22603 {
22604         uint32_t cntr_info_0;
22605         TALLOC_CTX *_mem_save_info_0;
22606         if (flags & NDR_IN) {
22607                 ZERO_STRUCT(r->out);
22608
22609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22611         }
22612         if (flags & NDR_OUT) {
22613                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22614                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22615                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22616                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22617                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22618                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22619                 }
22620                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22621                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22622                 }
22623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22624         }
22625         return NDR_ERR_SUCCESS;
22626 }
22627
22628 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22629 {
22630         uint32_t cntr_info_1;
22631         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22632         ndr->depth++;
22633         if (flags & NDR_SET_VALUES) {
22634                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22635         }
22636         if (flags & NDR_IN) {
22637                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22638                 ndr->depth++;
22639                 ndr_print_ptr(ndr, "servername", r->in.servername);
22640                 ndr->depth++;
22641                 if (r->in.servername) {
22642                         ndr_print_string(ndr, "servername", r->in.servername);
22643                 }
22644                 ndr->depth--;
22645                 ndr_print_uint32(ndr, "level", r->in.level);
22646                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22647                 ndr->depth++;
22648                 if (r->in.buffer) {
22649                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22650                 }
22651                 ndr->depth--;
22652                 ndr_print_uint32(ndr, "offered", r->in.offered);
22653                 ndr->depth--;
22654         }
22655         if (flags & NDR_OUT) {
22656                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22657                 ndr->depth++;
22658                 ndr_print_ptr(ndr, "count", r->out.count);
22659                 ndr->depth++;
22660                 ndr_print_uint32(ndr, "count", *r->out.count);
22661                 ndr->depth--;
22662                 ndr_print_ptr(ndr, "info", r->out.info);
22663                 ndr->depth++;
22664                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22665                 ndr->depth++;
22666                 for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
22667                         char *idx_1=NULL;
22668                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
22669                                 ndr_print_ptr(ndr, "info", r->out.info[cntr_info_1]);
22670                                 ndr->depth++;
22671                                 if (r->out.info[cntr_info_1]) {
22672                                         ndr_print_set_switch_value(ndr, r->out.info[cntr_info_1], r->in.level);
22673                                         ndr_print_spoolss_MonitorInfo(ndr, "info", r->out.info[cntr_info_1]);
22674                                 }
22675                                 ndr->depth--;
22676                                 free(idx_1);
22677                         }
22678                 }
22679                 ndr->depth--;
22680                 ndr->depth--;
22681                 ndr_print_ptr(ndr, "needed", r->out.needed);
22682                 ndr->depth++;
22683                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22684                 ndr->depth--;
22685                 ndr_print_WERROR(ndr, "result", r->out.result);
22686                 ndr->depth--;
22687         }
22688         ndr->depth--;
22689 }
22690
22691 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22692 {
22693         if (flags & NDR_IN) {
22694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22695                 if (r->in.server_name) {
22696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22699                         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));
22700                 }
22701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22705                 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));
22706         }
22707         if (flags & NDR_OUT) {
22708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22709         }
22710         return NDR_ERR_SUCCESS;
22711 }
22712
22713 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
22714 {
22715         uint32_t _ptr_server_name;
22716         TALLOC_CTX *_mem_save_server_name_0;
22717         if (flags & NDR_IN) {
22718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
22719                 if (_ptr_server_name) {
22720                         NDR_PULL_ALLOC(ndr, r->in.server_name);
22721                 } else {
22722                         r->in.server_name = NULL;
22723                 }
22724                 if (r->in.server_name) {
22725                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
22726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
22727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
22728                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
22729                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
22730                                 return 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));
22731                         }
22732                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
22733                         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));
22734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
22735                 }
22736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
22737                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
22738                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
22739                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
22740                         return 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));
22741                 }
22742                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
22743                 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));
22744         }
22745         if (flags & NDR_OUT) {
22746                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22747         }
22748         return NDR_ERR_SUCCESS;
22749 }
22750
22751 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
22752 {
22753         ndr_print_struct(ndr, name, "spoolss_AddPort");
22754         ndr->depth++;
22755         if (flags & NDR_SET_VALUES) {
22756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22757         }
22758         if (flags & NDR_IN) {
22759                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
22760                 ndr->depth++;
22761                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
22762                 ndr->depth++;
22763                 if (r->in.server_name) {
22764                         ndr_print_string(ndr, "server_name", r->in.server_name);
22765                 }
22766                 ndr->depth--;
22767                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
22768                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
22769                 ndr->depth--;
22770         }
22771         if (flags & NDR_OUT) {
22772                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
22773                 ndr->depth++;
22774                 ndr_print_WERROR(ndr, "result", r->out.result);
22775                 ndr->depth--;
22776         }
22777         ndr->depth--;
22778 }
22779
22780 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
22781 {
22782         if (flags & NDR_IN) {
22783         }
22784         if (flags & NDR_OUT) {
22785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22786         }
22787         return NDR_ERR_SUCCESS;
22788 }
22789
22790 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
22791 {
22792         if (flags & NDR_IN) {
22793         }
22794         if (flags & NDR_OUT) {
22795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22796         }
22797         return NDR_ERR_SUCCESS;
22798 }
22799
22800 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
22801 {
22802         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
22803         ndr->depth++;
22804         if (flags & NDR_SET_VALUES) {
22805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22806         }
22807         if (flags & NDR_IN) {
22808                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
22809                 ndr->depth++;
22810                 ndr->depth--;
22811         }
22812         if (flags & NDR_OUT) {
22813                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
22814                 ndr->depth++;
22815                 ndr_print_WERROR(ndr, "result", r->out.result);
22816                 ndr->depth--;
22817         }
22818         ndr->depth--;
22819 }
22820
22821 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
22822 {
22823         if (flags & NDR_IN) {
22824         }
22825         if (flags & NDR_OUT) {
22826                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22827         }
22828         return NDR_ERR_SUCCESS;
22829 }
22830
22831 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
22832 {
22833         if (flags & NDR_IN) {
22834         }
22835         if (flags & NDR_OUT) {
22836                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22837         }
22838         return NDR_ERR_SUCCESS;
22839 }
22840
22841 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
22842 {
22843         ndr_print_struct(ndr, name, "spoolss_DeletePort");
22844         ndr->depth++;
22845         if (flags & NDR_SET_VALUES) {
22846                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22847         }
22848         if (flags & NDR_IN) {
22849                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
22850                 ndr->depth++;
22851                 ndr->depth--;
22852         }
22853         if (flags & NDR_OUT) {
22854                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
22855                 ndr->depth++;
22856                 ndr_print_WERROR(ndr, "result", r->out.result);
22857                 ndr->depth--;
22858         }
22859         ndr->depth--;
22860 }
22861
22862 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
22863 {
22864         if (flags & NDR_IN) {
22865         }
22866         if (flags & NDR_OUT) {
22867                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22868         }
22869         return NDR_ERR_SUCCESS;
22870 }
22871
22872 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
22873 {
22874         if (flags & NDR_IN) {
22875         }
22876         if (flags & NDR_OUT) {
22877                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22878         }
22879         return NDR_ERR_SUCCESS;
22880 }
22881
22882 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
22883 {
22884         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
22885         ndr->depth++;
22886         if (flags & NDR_SET_VALUES) {
22887                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22888         }
22889         if (flags & NDR_IN) {
22890                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
22891                 ndr->depth++;
22892                 ndr->depth--;
22893         }
22894         if (flags & NDR_OUT) {
22895                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
22896                 ndr->depth++;
22897                 ndr_print_WERROR(ndr, "result", r->out.result);
22898                 ndr->depth--;
22899         }
22900         ndr->depth--;
22901 }
22902
22903 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
22904 {
22905         if (flags & NDR_IN) {
22906         }
22907         if (flags & NDR_OUT) {
22908                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22909         }
22910         return NDR_ERR_SUCCESS;
22911 }
22912
22913 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
22914 {
22915         if (flags & NDR_IN) {
22916         }
22917         if (flags & NDR_OUT) {
22918                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22919         }
22920         return NDR_ERR_SUCCESS;
22921 }
22922
22923 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
22924 {
22925         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
22926         ndr->depth++;
22927         if (flags & NDR_SET_VALUES) {
22928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22929         }
22930         if (flags & NDR_IN) {
22931                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
22932                 ndr->depth++;
22933                 ndr->depth--;
22934         }
22935         if (flags & NDR_OUT) {
22936                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
22937                 ndr->depth++;
22938                 ndr_print_WERROR(ndr, "result", r->out.result);
22939                 ndr->depth--;
22940         }
22941         ndr->depth--;
22942 }
22943
22944 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
22945 {
22946         if (flags & NDR_IN) {
22947         }
22948         if (flags & NDR_OUT) {
22949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22950         }
22951         return NDR_ERR_SUCCESS;
22952 }
22953
22954 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
22955 {
22956         if (flags & NDR_IN) {
22957         }
22958         if (flags & NDR_OUT) {
22959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22960         }
22961         return NDR_ERR_SUCCESS;
22962 }
22963
22964 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
22965 {
22966         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
22967         ndr->depth++;
22968         if (flags & NDR_SET_VALUES) {
22969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22970         }
22971         if (flags & NDR_IN) {
22972                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
22973                 ndr->depth++;
22974                 ndr->depth--;
22975         }
22976         if (flags & NDR_OUT) {
22977                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
22978                 ndr->depth++;
22979                 ndr_print_WERROR(ndr, "result", r->out.result);
22980                 ndr->depth--;
22981         }
22982         ndr->depth--;
22983 }
22984
22985 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
22986 {
22987         if (flags & NDR_IN) {
22988         }
22989         if (flags & NDR_OUT) {
22990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22991         }
22992         return NDR_ERR_SUCCESS;
22993 }
22994
22995 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
22996 {
22997         if (flags & NDR_IN) {
22998         }
22999         if (flags & NDR_OUT) {
23000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23001         }
23002         return NDR_ERR_SUCCESS;
23003 }
23004
23005 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23006 {
23007         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23008         ndr->depth++;
23009         if (flags & NDR_SET_VALUES) {
23010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23011         }
23012         if (flags & NDR_IN) {
23013                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23014                 ndr->depth++;
23015                 ndr->depth--;
23016         }
23017         if (flags & NDR_OUT) {
23018                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23019                 ndr->depth++;
23020                 ndr_print_WERROR(ndr, "result", r->out.result);
23021                 ndr->depth--;
23022         }
23023         ndr->depth--;
23024 }
23025
23026 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23027 {
23028         if (flags & NDR_IN) {
23029         }
23030         if (flags & NDR_OUT) {
23031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23032         }
23033         return NDR_ERR_SUCCESS;
23034 }
23035
23036 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23037 {
23038         if (flags & NDR_IN) {
23039         }
23040         if (flags & NDR_OUT) {
23041                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23042         }
23043         return NDR_ERR_SUCCESS;
23044 }
23045
23046 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23047 {
23048         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23049         ndr->depth++;
23050         if (flags & NDR_SET_VALUES) {
23051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23052         }
23053         if (flags & NDR_IN) {
23054                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23055                 ndr->depth++;
23056                 ndr->depth--;
23057         }
23058         if (flags & NDR_OUT) {
23059                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23060                 ndr->depth++;
23061                 ndr_print_WERROR(ndr, "result", r->out.result);
23062                 ndr->depth--;
23063         }
23064         ndr->depth--;
23065 }
23066
23067 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23068 {
23069         if (flags & NDR_IN) {
23070         }
23071         if (flags & NDR_OUT) {
23072                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23073         }
23074         return NDR_ERR_SUCCESS;
23075 }
23076
23077 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23078 {
23079         if (flags & NDR_IN) {
23080         }
23081         if (flags & NDR_OUT) {
23082                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23083         }
23084         return NDR_ERR_SUCCESS;
23085 }
23086
23087 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23088 {
23089         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23090         ndr->depth++;
23091         if (flags & NDR_SET_VALUES) {
23092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23093         }
23094         if (flags & NDR_IN) {
23095                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23096                 ndr->depth++;
23097                 ndr->depth--;
23098         }
23099         if (flags & NDR_OUT) {
23100                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23101                 ndr->depth++;
23102                 ndr_print_WERROR(ndr, "result", r->out.result);
23103                 ndr->depth--;
23104         }
23105         ndr->depth--;
23106 }
23107
23108 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23109 {
23110         if (flags & NDR_IN) {
23111         }
23112         if (flags & NDR_OUT) {
23113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23114         }
23115         return NDR_ERR_SUCCESS;
23116 }
23117
23118 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23119 {
23120         if (flags & NDR_IN) {
23121         }
23122         if (flags & NDR_OUT) {
23123                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23124         }
23125         return NDR_ERR_SUCCESS;
23126 }
23127
23128 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23129 {
23130         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23131         ndr->depth++;
23132         if (flags & NDR_SET_VALUES) {
23133                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23134         }
23135         if (flags & NDR_IN) {
23136                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23137                 ndr->depth++;
23138                 ndr->depth--;
23139         }
23140         if (flags & NDR_OUT) {
23141                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23142                 ndr->depth++;
23143                 ndr_print_WERROR(ndr, "result", r->out.result);
23144                 ndr->depth--;
23145         }
23146         ndr->depth--;
23147 }
23148
23149 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23150 {
23151         if (flags & NDR_IN) {
23152         }
23153         if (flags & NDR_OUT) {
23154                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23155         }
23156         return NDR_ERR_SUCCESS;
23157 }
23158
23159 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23160 {
23161         if (flags & NDR_IN) {
23162         }
23163         if (flags & NDR_OUT) {
23164                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23165         }
23166         return NDR_ERR_SUCCESS;
23167 }
23168
23169 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23170 {
23171         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23172         ndr->depth++;
23173         if (flags & NDR_SET_VALUES) {
23174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23175         }
23176         if (flags & NDR_IN) {
23177                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23178                 ndr->depth++;
23179                 ndr->depth--;
23180         }
23181         if (flags & NDR_OUT) {
23182                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23183                 ndr->depth++;
23184                 ndr_print_WERROR(ndr, "result", r->out.result);
23185                 ndr->depth--;
23186         }
23187         ndr->depth--;
23188 }
23189
23190 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23191 {
23192         if (flags & NDR_IN) {
23193         }
23194         if (flags & NDR_OUT) {
23195                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23196         }
23197         return NDR_ERR_SUCCESS;
23198 }
23199
23200 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23201 {
23202         if (flags & NDR_IN) {
23203         }
23204         if (flags & NDR_OUT) {
23205                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23206         }
23207         return NDR_ERR_SUCCESS;
23208 }
23209
23210 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23211 {
23212         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23213         ndr->depth++;
23214         if (flags & NDR_SET_VALUES) {
23215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23216         }
23217         if (flags & NDR_IN) {
23218                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23219                 ndr->depth++;
23220                 ndr->depth--;
23221         }
23222         if (flags & NDR_OUT) {
23223                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23224                 ndr->depth++;
23225                 ndr_print_WERROR(ndr, "result", r->out.result);
23226                 ndr->depth--;
23227         }
23228         ndr->depth--;
23229 }
23230
23231 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23232 {
23233         if (flags & NDR_IN) {
23234         }
23235         if (flags & NDR_OUT) {
23236                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23237         }
23238         return NDR_ERR_SUCCESS;
23239 }
23240
23241 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23242 {
23243         if (flags & NDR_IN) {
23244         }
23245         if (flags & NDR_OUT) {
23246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23247         }
23248         return NDR_ERR_SUCCESS;
23249 }
23250
23251 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23252 {
23253         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23254         ndr->depth++;
23255         if (flags & NDR_SET_VALUES) {
23256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23257         }
23258         if (flags & NDR_IN) {
23259                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23260                 ndr->depth++;
23261                 ndr->depth--;
23262         }
23263         if (flags & NDR_OUT) {
23264                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23265                 ndr->depth++;
23266                 ndr_print_WERROR(ndr, "result", r->out.result);
23267                 ndr->depth--;
23268         }
23269         ndr->depth--;
23270 }
23271
23272 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23273 {
23274         if (flags & NDR_IN) {
23275         }
23276         if (flags & NDR_OUT) {
23277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23278         }
23279         return NDR_ERR_SUCCESS;
23280 }
23281
23282 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23283 {
23284         if (flags & NDR_IN) {
23285         }
23286         if (flags & NDR_OUT) {
23287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23288         }
23289         return NDR_ERR_SUCCESS;
23290 }
23291
23292 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23293 {
23294         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23295         ndr->depth++;
23296         if (flags & NDR_SET_VALUES) {
23297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23298         }
23299         if (flags & NDR_IN) {
23300                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23301                 ndr->depth++;
23302                 ndr->depth--;
23303         }
23304         if (flags & NDR_OUT) {
23305                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23306                 ndr->depth++;
23307                 ndr_print_WERROR(ndr, "result", r->out.result);
23308                 ndr->depth--;
23309         }
23310         ndr->depth--;
23311 }
23312
23313 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23314 {
23315         if (flags & NDR_IN) {
23316         }
23317         if (flags & NDR_OUT) {
23318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23319         }
23320         return NDR_ERR_SUCCESS;
23321 }
23322
23323 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
23324 {
23325         if (flags & NDR_IN) {
23326         }
23327         if (flags & NDR_OUT) {
23328                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23329         }
23330         return NDR_ERR_SUCCESS;
23331 }
23332
23333 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23334 {
23335         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23336         ndr->depth++;
23337         if (flags & NDR_SET_VALUES) {
23338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23339         }
23340         if (flags & NDR_IN) {
23341                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23342                 ndr->depth++;
23343                 ndr->depth--;
23344         }
23345         if (flags & NDR_OUT) {
23346                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23347                 ndr->depth++;
23348                 ndr_print_WERROR(ndr, "result", r->out.result);
23349                 ndr->depth--;
23350         }
23351         ndr->depth--;
23352 }
23353
23354 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23355 {
23356         if (flags & NDR_IN) {
23357                 if (r->in.handle == NULL) {
23358                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23359                 }
23360                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23362                 if (r->in.data_type) {
23363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23366                         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));
23367                 }
23368                 if (r->in.devmode_ctr == NULL) {
23369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23370                 }
23371                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23372         }
23373         if (flags & NDR_OUT) {
23374                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23375         }
23376         return NDR_ERR_SUCCESS;
23377 }
23378
23379 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23380 {
23381         uint32_t _ptr_data_type;
23382         TALLOC_CTX *_mem_save_handle_0;
23383         TALLOC_CTX *_mem_save_data_type_0;
23384         TALLOC_CTX *_mem_save_devmode_ctr_0;
23385         if (flags & NDR_IN) {
23386                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23387                         NDR_PULL_ALLOC(ndr, r->in.handle);
23388                 }
23389                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23390                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23391                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23394                 if (_ptr_data_type) {
23395                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23396                 } else {
23397                         r->in.data_type = NULL;
23398                 }
23399                 if (r->in.data_type) {
23400                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23401                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23404                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23405                                 return 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));
23406                         }
23407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23408                         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));
23409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23410                 }
23411                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23412                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23413                 }
23414                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23415                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23416                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23418         }
23419         if (flags & NDR_OUT) {
23420                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23421         }
23422         return NDR_ERR_SUCCESS;
23423 }
23424
23425 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23426 {
23427         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23428         ndr->depth++;
23429         if (flags & NDR_SET_VALUES) {
23430                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23431         }
23432         if (flags & NDR_IN) {
23433                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23434                 ndr->depth++;
23435                 ndr_print_ptr(ndr, "handle", r->in.handle);
23436                 ndr->depth++;
23437                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23438                 ndr->depth--;
23439                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23440                 ndr->depth++;
23441                 if (r->in.data_type) {
23442                         ndr_print_string(ndr, "data_type", r->in.data_type);
23443                 }
23444                 ndr->depth--;
23445                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23446                 ndr->depth++;
23447                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23448                 ndr->depth--;
23449                 ndr->depth--;
23450         }
23451         if (flags & NDR_OUT) {
23452                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23453                 ndr->depth++;
23454                 ndr_print_WERROR(ndr, "result", r->out.result);
23455                 ndr->depth--;
23456         }
23457         ndr->depth--;
23458 }
23459
23460 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23461 {
23462         if (flags & NDR_IN) {
23463                 if (r->in.handle == NULL) {
23464                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23465                 }
23466                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23468                 if (r->in.architecture) {
23469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23472                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23473                 }
23474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23476                 if (r->in.buffer) {
23477                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23478                 }
23479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23482         }
23483         if (flags & NDR_OUT) {
23484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23485                 if (r->out.info) {
23486                         {
23487                                 struct ndr_push *_ndr_info;
23488                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23489                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23490                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23491                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23492                         }
23493                 }
23494                 if (r->out.needed == NULL) {
23495                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23496                 }
23497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23498                 if (r->out.server_major_version == NULL) {
23499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23500                 }
23501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
23502                 if (r->out.server_minor_version == NULL) {
23503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23504                 }
23505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
23506                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23507         }
23508         return NDR_ERR_SUCCESS;
23509 }
23510
23511 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
23512 {
23513         uint32_t _ptr_architecture;
23514         uint32_t _ptr_buffer;
23515         uint32_t _ptr_info;
23516         TALLOC_CTX *_mem_save_handle_0;
23517         TALLOC_CTX *_mem_save_architecture_0;
23518         TALLOC_CTX *_mem_save_buffer_0;
23519         TALLOC_CTX *_mem_save_info_0;
23520         TALLOC_CTX *_mem_save_needed_0;
23521         TALLOC_CTX *_mem_save_server_major_version_0;
23522         TALLOC_CTX *_mem_save_server_minor_version_0;
23523         if (flags & NDR_IN) {
23524                 ZERO_STRUCT(r->out);
23525
23526                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23527                         NDR_PULL_ALLOC(ndr, r->in.handle);
23528                 }
23529                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23530                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23531                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23532                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
23534                 if (_ptr_architecture) {
23535                         NDR_PULL_ALLOC(ndr, r->in.architecture);
23536                 } else {
23537                         r->in.architecture = NULL;
23538                 }
23539                 if (r->in.architecture) {
23540                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
23541                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
23542                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
23543                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
23544                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
23545                                 return 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));
23546                         }
23547                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
23548                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
23549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
23550                 }
23551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23553                 if (_ptr_buffer) {
23554                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23555                 } else {
23556                         r->in.buffer = NULL;
23557                 }
23558                 if (r->in.buffer) {
23559                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23560                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23561                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23563                 }
23564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
23566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
23567                 NDR_PULL_ALLOC(ndr, r->out.needed);
23568                 ZERO_STRUCTP(r->out.needed);
23569                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
23570                 ZERO_STRUCTP(r->out.server_major_version);
23571                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
23572                 ZERO_STRUCTP(r->out.server_minor_version);
23573         }
23574         if (flags & NDR_OUT) {
23575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23576                 if (_ptr_info) {
23577                         NDR_PULL_ALLOC(ndr, r->out.info);
23578                 } else {
23579                         r->out.info = NULL;
23580                 }
23581                 if (r->out.info) {
23582                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23583                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23584                         {
23585                                 struct ndr_pull *_ndr_info;
23586                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23587                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23588                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23589                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23590                         }
23591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23592                 }
23593                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23594                         NDR_PULL_ALLOC(ndr, r->out.needed);
23595                 }
23596                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23597                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23601                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
23602                 }
23603                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
23604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
23605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
23606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
23607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23608                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
23609                 }
23610                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
23611                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
23612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
23613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
23614                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23615         }
23616         return NDR_ERR_SUCCESS;
23617 }
23618
23619 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
23620 {
23621         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
23622         ndr->depth++;
23623         if (flags & NDR_SET_VALUES) {
23624                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23625         }
23626         if (flags & NDR_IN) {
23627                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
23628                 ndr->depth++;
23629                 ndr_print_ptr(ndr, "handle", r->in.handle);
23630                 ndr->depth++;
23631                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23632                 ndr->depth--;
23633                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
23634                 ndr->depth++;
23635                 if (r->in.architecture) {
23636                         ndr_print_string(ndr, "architecture", r->in.architecture);
23637                 }
23638                 ndr->depth--;
23639                 ndr_print_uint32(ndr, "level", r->in.level);
23640                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23641                 ndr->depth++;
23642                 if (r->in.buffer) {
23643                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23644                 }
23645                 ndr->depth--;
23646                 ndr_print_uint32(ndr, "offered", r->in.offered);
23647                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
23648                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
23649                 ndr->depth--;
23650         }
23651         if (flags & NDR_OUT) {
23652                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
23653                 ndr->depth++;
23654                 ndr_print_ptr(ndr, "info", r->out.info);
23655                 ndr->depth++;
23656                 if (r->out.info) {
23657                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23658                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
23659                 }
23660                 ndr->depth--;
23661                 ndr_print_ptr(ndr, "needed", r->out.needed);
23662                 ndr->depth++;
23663                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23664                 ndr->depth--;
23665                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
23666                 ndr->depth++;
23667                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
23668                 ndr->depth--;
23669                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
23670                 ndr->depth++;
23671                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
23672                 ndr->depth--;
23673                 ndr_print_WERROR(ndr, "result", r->out.result);
23674                 ndr->depth--;
23675         }
23676         ndr->depth--;
23677 }
23678
23679 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
23680 {
23681         if (flags & NDR_IN) {
23682         }
23683         if (flags & NDR_OUT) {
23684                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23685         }
23686         return NDR_ERR_SUCCESS;
23687 }
23688
23689 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
23690 {
23691         if (flags & NDR_IN) {
23692         }
23693         if (flags & NDR_OUT) {
23694                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23695         }
23696         return NDR_ERR_SUCCESS;
23697 }
23698
23699 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
23700 {
23701         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
23702         ndr->depth++;
23703         if (flags & NDR_SET_VALUES) {
23704                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23705         }
23706         if (flags & NDR_IN) {
23707                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
23708                 ndr->depth++;
23709                 ndr->depth--;
23710         }
23711         if (flags & NDR_OUT) {
23712                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
23713                 ndr->depth++;
23714                 ndr_print_WERROR(ndr, "result", r->out.result);
23715                 ndr->depth--;
23716         }
23717         ndr->depth--;
23718 }
23719
23720 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
23721 {
23722         if (flags & NDR_IN) {
23723         }
23724         if (flags & NDR_OUT) {
23725                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23726         }
23727         return NDR_ERR_SUCCESS;
23728 }
23729
23730 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
23731 {
23732         if (flags & NDR_IN) {
23733         }
23734         if (flags & NDR_OUT) {
23735                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23736         }
23737         return NDR_ERR_SUCCESS;
23738 }
23739
23740 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
23741 {
23742         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
23743         ndr->depth++;
23744         if (flags & NDR_SET_VALUES) {
23745                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23746         }
23747         if (flags & NDR_IN) {
23748                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
23749                 ndr->depth++;
23750                 ndr->depth--;
23751         }
23752         if (flags & NDR_OUT) {
23753                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
23754                 ndr->depth++;
23755                 ndr_print_WERROR(ndr, "result", r->out.result);
23756                 ndr->depth--;
23757         }
23758         ndr->depth--;
23759 }
23760
23761 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
23762 {
23763         if (flags & NDR_IN) {
23764                 if (r->in.handle == NULL) {
23765                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23766                 }
23767                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23768         }
23769         if (flags & NDR_OUT) {
23770                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23771         }
23772         return NDR_ERR_SUCCESS;
23773 }
23774
23775 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
23776 {
23777         TALLOC_CTX *_mem_save_handle_0;
23778         if (flags & NDR_IN) {
23779                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23780                         NDR_PULL_ALLOC(ndr, r->in.handle);
23781                 }
23782                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23783                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23784                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23786         }
23787         if (flags & NDR_OUT) {
23788                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23789         }
23790         return NDR_ERR_SUCCESS;
23791 }
23792
23793 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
23794 {
23795         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
23796         ndr->depth++;
23797         if (flags & NDR_SET_VALUES) {
23798                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23799         }
23800         if (flags & NDR_IN) {
23801                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
23802                 ndr->depth++;
23803                 ndr_print_ptr(ndr, "handle", r->in.handle);
23804                 ndr->depth++;
23805                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23806                 ndr->depth--;
23807                 ndr->depth--;
23808         }
23809         if (flags & NDR_OUT) {
23810                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
23811                 ndr->depth++;
23812                 ndr_print_WERROR(ndr, "result", r->out.result);
23813                 ndr->depth--;
23814         }
23815         ndr->depth--;
23816 }
23817
23818 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
23819 {
23820         if (flags & NDR_IN) {
23821         }
23822         if (flags & NDR_OUT) {
23823                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23824         }
23825         return NDR_ERR_SUCCESS;
23826 }
23827
23828 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
23829 {
23830         if (flags & NDR_IN) {
23831         }
23832         if (flags & NDR_OUT) {
23833                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23834         }
23835         return NDR_ERR_SUCCESS;
23836 }
23837
23838 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
23839 {
23840         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
23841         ndr->depth++;
23842         if (flags & NDR_SET_VALUES) {
23843                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23844         }
23845         if (flags & NDR_IN) {
23846                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
23847                 ndr->depth++;
23848                 ndr->depth--;
23849         }
23850         if (flags & NDR_OUT) {
23851                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
23852                 ndr->depth++;
23853                 ndr_print_WERROR(ndr, "result", r->out.result);
23854                 ndr->depth--;
23855         }
23856         ndr->depth--;
23857 }
23858
23859 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
23860 {
23861         if (flags & NDR_IN) {
23862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23865                 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));
23866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
23867                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
23869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23870                 if (r->in.buffer) {
23871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
23872                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
23873                 }
23874         }
23875         if (flags & NDR_OUT) {
23876                 if (r->out.handle == NULL) {
23877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23878                 }
23879                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23880                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23881         }
23882         return NDR_ERR_SUCCESS;
23883 }
23884
23885 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
23886 {
23887         uint32_t _ptr_buffer;
23888         TALLOC_CTX *_mem_save_buffer_0;
23889         TALLOC_CTX *_mem_save_handle_0;
23890         if (flags & NDR_IN) {
23891                 ZERO_STRUCT(r->out);
23892
23893                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23894                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23895                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23896                         return 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));
23897                 }
23898                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23899                 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));
23900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
23901                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
23903                 if (r->in.bufsize > 512) {
23904                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
23905                 }
23906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23907                 if (_ptr_buffer) {
23908                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23909                 } else {
23910                         r->in.buffer = NULL;
23911                 }
23912                 if (r->in.buffer) {
23913                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23914                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23916                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23917                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23919                 }
23920                 NDR_PULL_ALLOC(ndr, r->out.handle);
23921                 ZERO_STRUCTP(r->out.handle);
23922                 if (r->in.buffer) {
23923                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
23924                 }
23925         }
23926         if (flags & NDR_OUT) {
23927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23928                         NDR_PULL_ALLOC(ndr, r->out.handle);
23929                 }
23930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23931                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23935         }
23936         return NDR_ERR_SUCCESS;
23937 }
23938
23939 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
23940 {
23941         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
23942         ndr->depth++;
23943         if (flags & NDR_SET_VALUES) {
23944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23945         }
23946         if (flags & NDR_IN) {
23947                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
23948                 ndr->depth++;
23949                 ndr_print_string(ndr, "server_name", r->in.server_name);
23950                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
23951                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23952                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
23953                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23954                 ndr->depth++;
23955                 if (r->in.buffer) {
23956                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
23957                 }
23958                 ndr->depth--;
23959                 ndr->depth--;
23960         }
23961         if (flags & NDR_OUT) {
23962                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
23963                 ndr->depth++;
23964                 ndr_print_ptr(ndr, "handle", r->out.handle);
23965                 ndr->depth++;
23966                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23967                 ndr->depth--;
23968                 ndr_print_WERROR(ndr, "result", r->out.result);
23969                 ndr->depth--;
23970         }
23971         ndr->depth--;
23972 }
23973
23974 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
23975 {
23976         if (flags & NDR_IN) {
23977                 if (r->in.handle == NULL) {
23978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23979                 }
23980                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23981                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
23982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
23983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23984                 if (r->in.buffer) {
23985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
23986                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
23987                 }
23988         }
23989         if (flags & NDR_OUT) {
23990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23991         }
23992         return NDR_ERR_SUCCESS;
23993 }
23994
23995 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
23996 {
23997         uint32_t _ptr_buffer;
23998         TALLOC_CTX *_mem_save_handle_0;
23999         TALLOC_CTX *_mem_save_buffer_0;
24000         if (flags & NDR_IN) {
24001                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24002                         NDR_PULL_ALLOC(ndr, r->in.handle);
24003                 }
24004                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24005                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24006                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24008                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24010                 if (r->in.bufsize > 512) {
24011                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24012                 }
24013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24014                 if (_ptr_buffer) {
24015                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24016                 } else {
24017                         r->in.buffer = NULL;
24018                 }
24019                 if (r->in.buffer) {
24020                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24021                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24022                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24023                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24024                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24026                 }
24027                 if (r->in.buffer) {
24028                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24029                 }
24030         }
24031         if (flags & NDR_OUT) {
24032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24033         }
24034         return NDR_ERR_SUCCESS;
24035 }
24036
24037 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24038 {
24039         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24040         ndr->depth++;
24041         if (flags & NDR_SET_VALUES) {
24042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24043         }
24044         if (flags & NDR_IN) {
24045                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24046                 ndr->depth++;
24047                 ndr_print_ptr(ndr, "handle", r->in.handle);
24048                 ndr->depth++;
24049                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24050                 ndr->depth--;
24051                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24052                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24053                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24054                 ndr->depth++;
24055                 if (r->in.buffer) {
24056                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24057                 }
24058                 ndr->depth--;
24059                 ndr->depth--;
24060         }
24061         if (flags & NDR_OUT) {
24062                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24063                 ndr->depth++;
24064                 ndr_print_WERROR(ndr, "result", r->out.result);
24065                 ndr->depth--;
24066         }
24067         ndr->depth--;
24068 }
24069
24070 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24071 {
24072         if (flags & NDR_IN) {
24073                 if (r->in.handle == NULL) {
24074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24075                 }
24076                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24077         }
24078         if (flags & NDR_OUT) {
24079                 if (r->out.handle == NULL) {
24080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24081                 }
24082                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24084         }
24085         return NDR_ERR_SUCCESS;
24086 }
24087
24088 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24089 {
24090         TALLOC_CTX *_mem_save_handle_0;
24091         if (flags & NDR_IN) {
24092                 ZERO_STRUCT(r->out);
24093
24094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24095                         NDR_PULL_ALLOC(ndr, r->in.handle);
24096                 }
24097                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24098                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24099                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24101                 NDR_PULL_ALLOC(ndr, r->out.handle);
24102                 *r->out.handle = *r->in.handle;
24103         }
24104         if (flags & NDR_OUT) {
24105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24106                         NDR_PULL_ALLOC(ndr, r->out.handle);
24107                 }
24108                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24109                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24110                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24112                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24113         }
24114         return NDR_ERR_SUCCESS;
24115 }
24116
24117 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24118 {
24119         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24120         ndr->depth++;
24121         if (flags & NDR_SET_VALUES) {
24122                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24123         }
24124         if (flags & NDR_IN) {
24125                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24126                 ndr->depth++;
24127                 ndr_print_ptr(ndr, "handle", r->in.handle);
24128                 ndr->depth++;
24129                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24130                 ndr->depth--;
24131                 ndr->depth--;
24132         }
24133         if (flags & NDR_OUT) {
24134                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24135                 ndr->depth++;
24136                 ndr_print_ptr(ndr, "handle", r->out.handle);
24137                 ndr->depth++;
24138                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24139                 ndr->depth--;
24140                 ndr_print_WERROR(ndr, "result", r->out.result);
24141                 ndr->depth--;
24142         }
24143         ndr->depth--;
24144 }
24145
24146 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24147 {
24148         if (flags & NDR_IN) {
24149         }
24150         if (flags & NDR_OUT) {
24151                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24152         }
24153         return NDR_ERR_SUCCESS;
24154 }
24155
24156 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24157 {
24158         if (flags & NDR_IN) {
24159         }
24160         if (flags & NDR_OUT) {
24161                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24162         }
24163         return NDR_ERR_SUCCESS;
24164 }
24165
24166 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24167 {
24168         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24169         ndr->depth++;
24170         if (flags & NDR_SET_VALUES) {
24171                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24172         }
24173         if (flags & NDR_IN) {
24174                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24175                 ndr->depth++;
24176                 ndr->depth--;
24177         }
24178         if (flags & NDR_OUT) {
24179                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24180                 ndr->depth++;
24181                 ndr_print_WERROR(ndr, "result", r->out.result);
24182                 ndr->depth--;
24183         }
24184         ndr->depth--;
24185 }
24186
24187 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24188 {
24189         if (flags & NDR_IN) {
24190         }
24191         if (flags & NDR_OUT) {
24192                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24193         }
24194         return NDR_ERR_SUCCESS;
24195 }
24196
24197 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24198 {
24199         if (flags & NDR_IN) {
24200         }
24201         if (flags & NDR_OUT) {
24202                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24203         }
24204         return NDR_ERR_SUCCESS;
24205 }
24206
24207 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24208 {
24209         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24210         ndr->depth++;
24211         if (flags & NDR_SET_VALUES) {
24212                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24213         }
24214         if (flags & NDR_IN) {
24215                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24216                 ndr->depth++;
24217                 ndr->depth--;
24218         }
24219         if (flags & NDR_OUT) {
24220                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24221                 ndr->depth++;
24222                 ndr_print_WERROR(ndr, "result", r->out.result);
24223                 ndr->depth--;
24224         }
24225         ndr->depth--;
24226 }
24227
24228 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24229 {
24230         if (flags & NDR_IN) {
24231         }
24232         if (flags & NDR_OUT) {
24233                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24234         }
24235         return NDR_ERR_SUCCESS;
24236 }
24237
24238 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24239 {
24240         if (flags & NDR_IN) {
24241         }
24242         if (flags & NDR_OUT) {
24243                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24244         }
24245         return NDR_ERR_SUCCESS;
24246 }
24247
24248 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24249 {
24250         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24251         ndr->depth++;
24252         if (flags & NDR_SET_VALUES) {
24253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24254         }
24255         if (flags & NDR_IN) {
24256                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24257                 ndr->depth++;
24258                 ndr->depth--;
24259         }
24260         if (flags & NDR_OUT) {
24261                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24262                 ndr->depth++;
24263                 ndr_print_WERROR(ndr, "result", r->out.result);
24264                 ndr->depth--;
24265         }
24266         ndr->depth--;
24267 }
24268
24269 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24270 {
24271         if (flags & NDR_IN) {
24272         }
24273         if (flags & NDR_OUT) {
24274                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24275         }
24276         return NDR_ERR_SUCCESS;
24277 }
24278
24279 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24280 {
24281         if (flags & NDR_IN) {
24282         }
24283         if (flags & NDR_OUT) {
24284                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24285         }
24286         return NDR_ERR_SUCCESS;
24287 }
24288
24289 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24290 {
24291         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24292         ndr->depth++;
24293         if (flags & NDR_SET_VALUES) {
24294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24295         }
24296         if (flags & NDR_IN) {
24297                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24298                 ndr->depth++;
24299                 ndr->depth--;
24300         }
24301         if (flags & NDR_OUT) {
24302                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24303                 ndr->depth++;
24304                 ndr_print_WERROR(ndr, "result", r->out.result);
24305                 ndr->depth--;
24306         }
24307         ndr->depth--;
24308 }
24309
24310 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24311 {
24312         if (flags & NDR_IN) {
24313                 if (r->in.handle == NULL) {
24314                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24315                 }
24316                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24317                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24320                 if (r->in.local_machine) {
24321                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24322                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24324                         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));
24325                 }
24326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24328                 if (r->in.notify_options) {
24329                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24330                 }
24331         }
24332         if (flags & NDR_OUT) {
24333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24334         }
24335         return NDR_ERR_SUCCESS;
24336 }
24337
24338 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24339 {
24340         uint32_t _ptr_local_machine;
24341         uint32_t _ptr_notify_options;
24342         TALLOC_CTX *_mem_save_handle_0;
24343         TALLOC_CTX *_mem_save_local_machine_0;
24344         TALLOC_CTX *_mem_save_notify_options_0;
24345         if (flags & NDR_IN) {
24346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24347                         NDR_PULL_ALLOC(ndr, r->in.handle);
24348                 }
24349                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24350                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24351                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24353                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24355                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24356                 if (_ptr_local_machine) {
24357                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24358                 } else {
24359                         r->in.local_machine = NULL;
24360                 }
24361                 if (r->in.local_machine) {
24362                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24363                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24366                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24367                                 return 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));
24368                         }
24369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24370                         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));
24371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24372                 }
24373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24375                 if (_ptr_notify_options) {
24376                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24377                 } else {
24378                         r->in.notify_options = NULL;
24379                 }
24380                 if (r->in.notify_options) {
24381                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24383                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24385                 }
24386         }
24387         if (flags & NDR_OUT) {
24388                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24389         }
24390         return NDR_ERR_SUCCESS;
24391 }
24392
24393 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24394 {
24395         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24396         ndr->depth++;
24397         if (flags & NDR_SET_VALUES) {
24398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24399         }
24400         if (flags & NDR_IN) {
24401                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24402                 ndr->depth++;
24403                 ndr_print_ptr(ndr, "handle", r->in.handle);
24404                 ndr->depth++;
24405                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24406                 ndr->depth--;
24407                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24408                 ndr_print_uint32(ndr, "options", r->in.options);
24409                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24410                 ndr->depth++;
24411                 if (r->in.local_machine) {
24412                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24413                 }
24414                 ndr->depth--;
24415                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24416                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24417                 ndr->depth++;
24418                 if (r->in.notify_options) {
24419                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24420                 }
24421                 ndr->depth--;
24422                 ndr->depth--;
24423         }
24424         if (flags & NDR_OUT) {
24425                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24426                 ndr->depth++;
24427                 ndr_print_WERROR(ndr, "result", r->out.result);
24428                 ndr->depth--;
24429         }
24430         ndr->depth--;
24431 }
24432
24433 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24434 {
24435         if (flags & NDR_IN) {
24436                 if (r->in.handle == NULL) {
24437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24438                 }
24439                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24441                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24443                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24444                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24445         }
24446         if (flags & NDR_OUT) {
24447                 if (r->out.reply_result == NULL) {
24448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24449                 }
24450                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24451                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24452         }
24453         return NDR_ERR_SUCCESS;
24454 }
24455
24456 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24457 {
24458         TALLOC_CTX *_mem_save_handle_0;
24459         TALLOC_CTX *_mem_save_reply_result_0;
24460         if (flags & NDR_IN) {
24461                 ZERO_STRUCT(r->out);
24462
24463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24464                         NDR_PULL_ALLOC(ndr, r->in.handle);
24465                 }
24466                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24467                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24468                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24471                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24473                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24474                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24475                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24476                 ZERO_STRUCTP(r->out.reply_result);
24477         }
24478         if (flags & NDR_OUT) {
24479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24480                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24481                 }
24482                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24483                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24484                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24486                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24487         }
24488         return NDR_ERR_SUCCESS;
24489 }
24490
24491 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24492 {
24493         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24494         ndr->depth++;
24495         if (flags & NDR_SET_VALUES) {
24496                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24497         }
24498         if (flags & NDR_IN) {
24499                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
24500                 ndr->depth++;
24501                 ndr_print_ptr(ndr, "handle", r->in.handle);
24502                 ndr->depth++;
24503                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24504                 ndr->depth--;
24505                 ndr_print_uint32(ndr, "color", r->in.color);
24506                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24507                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
24508                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
24509                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
24510                 ndr->depth--;
24511         }
24512         if (flags & NDR_OUT) {
24513                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
24514                 ndr->depth++;
24515                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
24516                 ndr->depth++;
24517                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
24518                 ndr->depth--;
24519                 ndr_print_WERROR(ndr, "result", r->out.result);
24520                 ndr->depth--;
24521         }
24522         ndr->depth--;
24523 }
24524
24525 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
24526 {
24527         if (flags & NDR_IN) {
24528                 if (r->in.handle == NULL) {
24529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24530                 }
24531                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
24533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
24534                 if (r->in.options) {
24535                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24536                 }
24537         }
24538         if (flags & NDR_OUT) {
24539                 if (r->out.info == NULL) {
24540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24541                 }
24542                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
24543                 if (*r->out.info) {
24544                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
24545                 }
24546                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24547         }
24548         return NDR_ERR_SUCCESS;
24549 }
24550
24551 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
24552 {
24553         uint32_t _ptr_options;
24554         uint32_t _ptr_info;
24555         TALLOC_CTX *_mem_save_handle_0;
24556         TALLOC_CTX *_mem_save_options_0;
24557         TALLOC_CTX *_mem_save_info_0;
24558         TALLOC_CTX *_mem_save_info_1;
24559         if (flags & NDR_IN) {
24560                 ZERO_STRUCT(r->out);
24561
24562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24563                         NDR_PULL_ALLOC(ndr, r->in.handle);
24564                 }
24565                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24566                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24567                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
24570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
24571                 if (_ptr_options) {
24572                         NDR_PULL_ALLOC(ndr, r->in.options);
24573                 } else {
24574                         r->in.options = NULL;
24575                 }
24576                 if (r->in.options) {
24577                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24578                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
24579                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
24581                 }
24582                 NDR_PULL_ALLOC(ndr, r->out.info);
24583                 ZERO_STRUCTP(r->out.info);
24584         }
24585         if (flags & NDR_OUT) {
24586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24587                         NDR_PULL_ALLOC(ndr, r->out.info);
24588                 }
24589                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24590                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
24591                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24592                 if (_ptr_info) {
24593                         NDR_PULL_ALLOC(ndr, *r->out.info);
24594                 } else {
24595                         *r->out.info = NULL;
24596                 }
24597                 if (*r->out.info) {
24598                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
24599                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
24600                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
24601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
24602                 }
24603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
24604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24605         }
24606         return NDR_ERR_SUCCESS;
24607 }
24608
24609 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
24610 {
24611         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
24612         ndr->depth++;
24613         if (flags & NDR_SET_VALUES) {
24614                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24615         }
24616         if (flags & NDR_IN) {
24617                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
24618                 ndr->depth++;
24619                 ndr_print_ptr(ndr, "handle", r->in.handle);
24620                 ndr->depth++;
24621                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24622                 ndr->depth--;
24623                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
24624                 ndr_print_ptr(ndr, "options", r->in.options);
24625                 ndr->depth++;
24626                 if (r->in.options) {
24627                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
24628                 }
24629                 ndr->depth--;
24630                 ndr->depth--;
24631         }
24632         if (flags & NDR_OUT) {
24633                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
24634                 ndr->depth++;
24635                 ndr_print_ptr(ndr, "info", r->out.info);
24636                 ndr->depth++;
24637                 ndr_print_ptr(ndr, "info", *r->out.info);
24638                 ndr->depth++;
24639                 if (*r->out.info) {
24640                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
24641                 }
24642                 ndr->depth--;
24643                 ndr->depth--;
24644                 ndr_print_WERROR(ndr, "result", r->out.result);
24645                 ndr->depth--;
24646         }
24647         ndr->depth--;
24648 }
24649
24650 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
24651 {
24652         if (flags & NDR_IN) {
24653         }
24654         if (flags & NDR_OUT) {
24655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24656         }
24657         return NDR_ERR_SUCCESS;
24658 }
24659
24660 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
24661 {
24662         if (flags & NDR_IN) {
24663         }
24664         if (flags & NDR_OUT) {
24665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24666         }
24667         return NDR_ERR_SUCCESS;
24668 }
24669
24670 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
24671 {
24672         ndr_print_struct(ndr, name, "spoolss_44");
24673         ndr->depth++;
24674         if (flags & NDR_SET_VALUES) {
24675                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24676         }
24677         if (flags & NDR_IN) {
24678                 ndr_print_struct(ndr, "in", "spoolss_44");
24679                 ndr->depth++;
24680                 ndr->depth--;
24681         }
24682         if (flags & NDR_OUT) {
24683                 ndr_print_struct(ndr, "out", "spoolss_44");
24684                 ndr->depth++;
24685                 ndr_print_WERROR(ndr, "result", r->out.result);
24686                 ndr->depth--;
24687         }
24688         ndr->depth--;
24689 }
24690
24691 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
24692 {
24693         if (flags & NDR_IN) {
24694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
24695                 if (r->in.printername) {
24696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
24697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
24699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24700                 }
24701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
24702                 if (r->in.datatype) {
24703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
24704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24705                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
24706                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24707                 }
24708                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
24709                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
24710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24711                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
24712                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
24713         }
24714         if (flags & NDR_OUT) {
24715                 if (r->out.handle == NULL) {
24716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24717                 }
24718                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24719                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24720         }
24721         return NDR_ERR_SUCCESS;
24722 }
24723
24724 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
24725 {
24726         uint32_t _ptr_printername;
24727         uint32_t _ptr_datatype;
24728         TALLOC_CTX *_mem_save_printername_0;
24729         TALLOC_CTX *_mem_save_datatype_0;
24730         TALLOC_CTX *_mem_save_handle_0;
24731         if (flags & NDR_IN) {
24732                 ZERO_STRUCT(r->out);
24733
24734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
24735                 if (_ptr_printername) {
24736                         NDR_PULL_ALLOC(ndr, r->in.printername);
24737                 } else {
24738                         r->in.printername = NULL;
24739                 }
24740                 if (r->in.printername) {
24741                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24742                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
24743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
24744                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
24745                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
24746                                 return 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));
24747                         }
24748                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
24749                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
24750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
24751                 }
24752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
24753                 if (_ptr_datatype) {
24754                         NDR_PULL_ALLOC(ndr, r->in.datatype);
24755                 } else {
24756                         r->in.datatype = NULL;
24757                 }
24758                 if (r->in.datatype) {
24759                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
24760                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
24761                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
24762                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
24763                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
24764                                 return 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));
24765                         }
24766                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
24767                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
24768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
24769                 }
24770                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
24771                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
24772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24773                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
24774                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
24775                 NDR_PULL_ALLOC(ndr, r->out.handle);
24776                 ZERO_STRUCTP(r->out.handle);
24777         }
24778         if (flags & NDR_OUT) {
24779                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24780                         NDR_PULL_ALLOC(ndr, r->out.handle);
24781                 }
24782                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24783                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24784                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24787         }
24788         return NDR_ERR_SUCCESS;
24789 }
24790
24791 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
24792 {
24793         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
24794         ndr->depth++;
24795         if (flags & NDR_SET_VALUES) {
24796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24797         }
24798         if (flags & NDR_IN) {
24799                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
24800                 ndr->depth++;
24801                 ndr_print_ptr(ndr, "printername", r->in.printername);
24802                 ndr->depth++;
24803                 if (r->in.printername) {
24804                         ndr_print_string(ndr, "printername", r->in.printername);
24805                 }
24806                 ndr->depth--;
24807                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
24808                 ndr->depth++;
24809                 if (r->in.datatype) {
24810                         ndr_print_string(ndr, "datatype", r->in.datatype);
24811                 }
24812                 ndr->depth--;
24813                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
24814                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
24815                 ndr_print_uint32(ndr, "level", r->in.level);
24816                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
24817                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
24818                 ndr->depth--;
24819         }
24820         if (flags & NDR_OUT) {
24821                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
24822                 ndr->depth++;
24823                 ndr_print_ptr(ndr, "handle", r->out.handle);
24824                 ndr->depth++;
24825                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24826                 ndr->depth--;
24827                 ndr_print_WERROR(ndr, "result", r->out.result);
24828                 ndr->depth--;
24829         }
24830         ndr->depth--;
24831 }
24832
24833 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
24834 {
24835         if (flags & NDR_IN) {
24836                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
24837                 if (r->in.server) {
24838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
24839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
24841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24842                 }
24843                 if (r->in.info_ctr == NULL) {
24844                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24845                 }
24846                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
24847                 if (r->in.devmode_ctr == NULL) {
24848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24849                 }
24850                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24851                 if (r->in.secdesc_ctr == NULL) {
24852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24853                 }
24854                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
24855                 if (r->in.userlevel_ctr == NULL) {
24856                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24857                 }
24858                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
24859         }
24860         if (flags & NDR_OUT) {
24861                 if (r->out.handle == NULL) {
24862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24863                 }
24864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24866         }
24867         return NDR_ERR_SUCCESS;
24868 }
24869
24870 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
24871 {
24872         uint32_t _ptr_server;
24873         TALLOC_CTX *_mem_save_server_0;
24874         TALLOC_CTX *_mem_save_info_ctr_0;
24875         TALLOC_CTX *_mem_save_devmode_ctr_0;
24876         TALLOC_CTX *_mem_save_secdesc_ctr_0;
24877         TALLOC_CTX *_mem_save_userlevel_ctr_0;
24878         TALLOC_CTX *_mem_save_handle_0;
24879         if (flags & NDR_IN) {
24880                 ZERO_STRUCT(r->out);
24881
24882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
24883                 if (_ptr_server) {
24884                         NDR_PULL_ALLOC(ndr, r->in.server);
24885                 } else {
24886                         r->in.server = NULL;
24887                 }
24888                 if (r->in.server) {
24889                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
24890                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
24891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
24892                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
24893                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
24894                                 return 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));
24895                         }
24896                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
24897                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
24898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
24899                 }
24900                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24901                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
24902                 }
24903                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24904                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
24905                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
24906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24907                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24908                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24909                 }
24910                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24911                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24912                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24913                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24915                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
24916                 }
24917                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
24919                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
24920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24922                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
24923                 }
24924                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
24926                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
24927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24928                 NDR_PULL_ALLOC(ndr, r->out.handle);
24929                 ZERO_STRUCTP(r->out.handle);
24930         }
24931         if (flags & NDR_OUT) {
24932                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24933                         NDR_PULL_ALLOC(ndr, r->out.handle);
24934                 }
24935                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24936                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24937                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24938                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24939                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24940         }
24941         return NDR_ERR_SUCCESS;
24942 }
24943
24944 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
24945 {
24946         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
24947         ndr->depth++;
24948         if (flags & NDR_SET_VALUES) {
24949                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24950         }
24951         if (flags & NDR_IN) {
24952                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
24953                 ndr->depth++;
24954                 ndr_print_ptr(ndr, "server", r->in.server);
24955                 ndr->depth++;
24956                 if (r->in.server) {
24957                         ndr_print_string(ndr, "server", r->in.server);
24958                 }
24959                 ndr->depth--;
24960                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
24961                 ndr->depth++;
24962                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
24963                 ndr->depth--;
24964                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24965                 ndr->depth++;
24966                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24967                 ndr->depth--;
24968                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
24969                 ndr->depth++;
24970                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
24971                 ndr->depth--;
24972                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
24973                 ndr->depth++;
24974                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
24975                 ndr->depth--;
24976                 ndr->depth--;
24977         }
24978         if (flags & NDR_OUT) {
24979                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
24980                 ndr->depth++;
24981                 ndr_print_ptr(ndr, "handle", r->out.handle);
24982                 ndr->depth++;
24983                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24984                 ndr->depth--;
24985                 ndr_print_WERROR(ndr, "result", r->out.result);
24986                 ndr->depth--;
24987         }
24988         ndr->depth--;
24989 }
24990
24991 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
24992 {
24993         if (flags & NDR_IN) {
24994         }
24995         if (flags & NDR_OUT) {
24996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24997         }
24998         return NDR_ERR_SUCCESS;
24999 }
25000
25001 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25002 {
25003         if (flags & NDR_IN) {
25004         }
25005         if (flags & NDR_OUT) {
25006                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25007         }
25008         return NDR_ERR_SUCCESS;
25009 }
25010
25011 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25012 {
25013         ndr_print_struct(ndr, name, "spoolss_47");
25014         ndr->depth++;
25015         if (flags & NDR_SET_VALUES) {
25016                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25017         }
25018         if (flags & NDR_IN) {
25019                 ndr_print_struct(ndr, "in", "spoolss_47");
25020                 ndr->depth++;
25021                 ndr->depth--;
25022         }
25023         if (flags & NDR_OUT) {
25024                 ndr_print_struct(ndr, "out", "spoolss_47");
25025                 ndr->depth++;
25026                 ndr_print_WERROR(ndr, "result", r->out.result);
25027                 ndr->depth--;
25028         }
25029         ndr->depth--;
25030 }
25031
25032 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25033 {
25034         if (flags & NDR_IN) {
25035                 if (r->in.handle == NULL) {
25036                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25037                 }
25038                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25042         }
25043         if (flags & NDR_OUT) {
25044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25045                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25046                 if (r->out.value_needed == NULL) {
25047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25048                 }
25049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25050                 if (r->out.printerdata_type == NULL) {
25051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25052                 }
25053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
25054                 if (r->out.buffer == NULL) {
25055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25056                 }
25057                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
25058                 if (r->out.data_needed == NULL) {
25059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25060                 }
25061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25063         }
25064         return NDR_ERR_SUCCESS;
25065 }
25066
25067 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25068 {
25069         TALLOC_CTX *_mem_save_handle_0;
25070         TALLOC_CTX *_mem_save_value_needed_0;
25071         TALLOC_CTX *_mem_save_printerdata_type_0;
25072         TALLOC_CTX *_mem_save_buffer_0;
25073         TALLOC_CTX *_mem_save_data_needed_0;
25074         if (flags & NDR_IN) {
25075                 ZERO_STRUCT(r->out);
25076
25077                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25078                         NDR_PULL_ALLOC(ndr, r->in.handle);
25079                 }
25080                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25081                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25082                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25083                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25087                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25088                 ZERO_STRUCTP(r->out.value_needed);
25089                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25090                 ZERO_STRUCTP(r->out.printerdata_type);
25091                 NDR_PULL_ALLOC(ndr, r->out.buffer);
25092                 ZERO_STRUCTP(r->out.buffer);
25093                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25094                 ZERO_STRUCTP(r->out.data_needed);
25095         }
25096         if (flags & NDR_OUT) {
25097                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25098                 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));
25099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25100                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25101                 }
25102                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25103                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25106                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25107                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25108                 }
25109                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25110                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
25111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
25112                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
25113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25114                         NDR_PULL_ALLOC(ndr, r->out.buffer);
25115                 }
25116                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25117                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
25118                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
25119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
25120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25121                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25122                 }
25123                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25124                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25127                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25128                 if (r->out.value_name) {
25129                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25130                 }
25131         }
25132         return NDR_ERR_SUCCESS;
25133 }
25134
25135 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25136 {
25137         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25138         ndr->depth++;
25139         if (flags & NDR_SET_VALUES) {
25140                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25141         }
25142         if (flags & NDR_IN) {
25143                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25144                 ndr->depth++;
25145                 ndr_print_ptr(ndr, "handle", r->in.handle);
25146                 ndr->depth++;
25147                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25148                 ndr->depth--;
25149                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25150                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25151                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25152                 ndr->depth--;
25153         }
25154         if (flags & NDR_OUT) {
25155                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25156                 ndr->depth++;
25157                 ndr_print_string(ndr, "value_name", r->out.value_name);
25158                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25159                 ndr->depth++;
25160                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25161                 ndr->depth--;
25162                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
25163                 ndr->depth++;
25164                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
25165                 ndr->depth--;
25166                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25167                 ndr->depth++;
25168                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
25169                 ndr->depth--;
25170                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25171                 ndr->depth++;
25172                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25173                 ndr->depth--;
25174                 ndr_print_WERROR(ndr, "result", r->out.result);
25175                 ndr->depth--;
25176         }
25177         ndr->depth--;
25178 }
25179
25180 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25181 {
25182         if (flags & NDR_IN) {
25183                 if (r->in.handle == NULL) {
25184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25185                 }
25186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25190                 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));
25191         }
25192         if (flags & NDR_OUT) {
25193                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25194         }
25195         return NDR_ERR_SUCCESS;
25196 }
25197
25198 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25199 {
25200         TALLOC_CTX *_mem_save_handle_0;
25201         if (flags & NDR_IN) {
25202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25203                         NDR_PULL_ALLOC(ndr, r->in.handle);
25204                 }
25205                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25209                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25210                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25211                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25212                         return 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));
25213                 }
25214                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25215                 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));
25216         }
25217         if (flags & NDR_OUT) {
25218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25219         }
25220         return NDR_ERR_SUCCESS;
25221 }
25222
25223 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25224 {
25225         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25226         ndr->depth++;
25227         if (flags & NDR_SET_VALUES) {
25228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25229         }
25230         if (flags & NDR_IN) {
25231                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25232                 ndr->depth++;
25233                 ndr_print_ptr(ndr, "handle", r->in.handle);
25234                 ndr->depth++;
25235                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25236                 ndr->depth--;
25237                 ndr_print_string(ndr, "value_name", r->in.value_name);
25238                 ndr->depth--;
25239         }
25240         if (flags & NDR_OUT) {
25241                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25242                 ndr->depth++;
25243                 ndr_print_WERROR(ndr, "result", r->out.result);
25244                 ndr->depth--;
25245         }
25246         ndr->depth--;
25247 }
25248
25249 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25250 {
25251         if (flags & NDR_IN) {
25252         }
25253         if (flags & NDR_OUT) {
25254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25255         }
25256         return NDR_ERR_SUCCESS;
25257 }
25258
25259 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25260 {
25261         if (flags & NDR_IN) {
25262         }
25263         if (flags & NDR_OUT) {
25264                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25265         }
25266         return NDR_ERR_SUCCESS;
25267 }
25268
25269 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25270 {
25271         ndr_print_struct(ndr, name, "spoolss_4a");
25272         ndr->depth++;
25273         if (flags & NDR_SET_VALUES) {
25274                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25275         }
25276         if (flags & NDR_IN) {
25277                 ndr_print_struct(ndr, "in", "spoolss_4a");
25278                 ndr->depth++;
25279                 ndr->depth--;
25280         }
25281         if (flags & NDR_OUT) {
25282                 ndr_print_struct(ndr, "out", "spoolss_4a");
25283                 ndr->depth++;
25284                 ndr_print_WERROR(ndr, "result", r->out.result);
25285                 ndr->depth--;
25286         }
25287         ndr->depth--;
25288 }
25289
25290 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25291 {
25292         if (flags & NDR_IN) {
25293         }
25294         if (flags & NDR_OUT) {
25295                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25296         }
25297         return NDR_ERR_SUCCESS;
25298 }
25299
25300 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25301 {
25302         if (flags & NDR_IN) {
25303         }
25304         if (flags & NDR_OUT) {
25305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25306         }
25307         return NDR_ERR_SUCCESS;
25308 }
25309
25310 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25311 {
25312         ndr_print_struct(ndr, name, "spoolss_4b");
25313         ndr->depth++;
25314         if (flags & NDR_SET_VALUES) {
25315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25316         }
25317         if (flags & NDR_IN) {
25318                 ndr_print_struct(ndr, "in", "spoolss_4b");
25319                 ndr->depth++;
25320                 ndr->depth--;
25321         }
25322         if (flags & NDR_OUT) {
25323                 ndr_print_struct(ndr, "out", "spoolss_4b");
25324                 ndr->depth++;
25325                 ndr_print_WERROR(ndr, "result", r->out.result);
25326                 ndr->depth--;
25327         }
25328         ndr->depth--;
25329 }
25330
25331 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25332 {
25333         if (flags & NDR_IN) {
25334         }
25335         if (flags & NDR_OUT) {
25336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25337         }
25338         return NDR_ERR_SUCCESS;
25339 }
25340
25341 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25342 {
25343         if (flags & NDR_IN) {
25344         }
25345         if (flags & NDR_OUT) {
25346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25347         }
25348         return NDR_ERR_SUCCESS;
25349 }
25350
25351 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25352 {
25353         ndr_print_struct(ndr, name, "spoolss_4c");
25354         ndr->depth++;
25355         if (flags & NDR_SET_VALUES) {
25356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25357         }
25358         if (flags & NDR_IN) {
25359                 ndr_print_struct(ndr, "in", "spoolss_4c");
25360                 ndr->depth++;
25361                 ndr->depth--;
25362         }
25363         if (flags & NDR_OUT) {
25364                 ndr_print_struct(ndr, "out", "spoolss_4c");
25365                 ndr->depth++;
25366                 ndr_print_WERROR(ndr, "result", r->out.result);
25367                 ndr->depth--;
25368         }
25369         ndr->depth--;
25370 }
25371
25372 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25373 {
25374         if (flags & NDR_IN) {
25375                 if (r->in.handle == NULL) {
25376                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25377                 }
25378                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25382                 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));
25383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25386                 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));
25387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
25388                 if (r->in.buffer == NULL) {
25389                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25390                 }
25391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25392                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25394         }
25395         if (flags & NDR_OUT) {
25396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25397         }
25398         return NDR_ERR_SUCCESS;
25399 }
25400
25401 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25402 {
25403         TALLOC_CTX *_mem_save_handle_0;
25404         if (flags & NDR_IN) {
25405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25406                         NDR_PULL_ALLOC(ndr, r->in.handle);
25407                 }
25408                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25410                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25412                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25413                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25414                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25415                         return 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));
25416                 }
25417                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25418                 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));
25419                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25420                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25421                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25422                         return 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));
25423                 }
25424                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25425                 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));
25426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
25427                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25429                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25430                 }
25431                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25433                 if (r->in.buffer) {
25434                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25435                 }
25436         }
25437         if (flags & NDR_OUT) {
25438                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25439         }
25440         return NDR_ERR_SUCCESS;
25441 }
25442
25443 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25444 {
25445         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25446         ndr->depth++;
25447         if (flags & NDR_SET_VALUES) {
25448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25449         }
25450         if (flags & NDR_IN) {
25451                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25452                 ndr->depth++;
25453                 ndr_print_ptr(ndr, "handle", r->in.handle);
25454                 ndr->depth++;
25455                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25456                 ndr->depth--;
25457                 ndr_print_string(ndr, "key_name", r->in.key_name);
25458                 ndr_print_string(ndr, "value_name", r->in.value_name);
25459                 ndr_print_uint32(ndr, "type", r->in.type);
25460                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25461                 ndr->depth++;
25462                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25463                 ndr->depth--;
25464                 ndr_print_uint32(ndr, "offered", r->in.offered);
25465                 ndr->depth--;
25466         }
25467         if (flags & NDR_OUT) {
25468                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25469                 ndr->depth++;
25470                 ndr_print_WERROR(ndr, "result", r->out.result);
25471                 ndr->depth--;
25472         }
25473         ndr->depth--;
25474 }
25475
25476 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25477 {
25478         if (flags & NDR_IN) {
25479                 if (r->in.handle == NULL) {
25480                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25481                 }
25482                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25486                 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));
25487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25490                 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));
25491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25492         }
25493         if (flags & NDR_OUT) {
25494                 if (r->out.type == NULL) {
25495                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25496                 }
25497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
25498                 if (r->out.buffer == NULL) {
25499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25500                 }
25501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25502                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
25503                 if (r->out.needed == NULL) {
25504                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25505                 }
25506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25507                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25508         }
25509         return NDR_ERR_SUCCESS;
25510 }
25511
25512 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
25513 {
25514         TALLOC_CTX *_mem_save_handle_0;
25515         TALLOC_CTX *_mem_save_type_0;
25516         TALLOC_CTX *_mem_save_needed_0;
25517         if (flags & NDR_IN) {
25518                 ZERO_STRUCT(r->out);
25519
25520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25521                         NDR_PULL_ALLOC(ndr, r->in.handle);
25522                 }
25523                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25524                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25525                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25527                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25528                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25529                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25530                         return 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));
25531                 }
25532                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25533                 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));
25534                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25535                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25536                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25537                         return 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));
25538                 }
25539                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25540                 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));
25541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25542                 NDR_PULL_ALLOC(ndr, r->out.type);
25543                 ZERO_STRUCTP(r->out.type);
25544                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
25545                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
25546                 NDR_PULL_ALLOC(ndr, r->out.needed);
25547                 ZERO_STRUCTP(r->out.needed);
25548         }
25549         if (flags & NDR_OUT) {
25550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25551                         NDR_PULL_ALLOC(ndr, r->out.type);
25552                 }
25553                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
25556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25557                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
25558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25559                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
25560                 }
25561                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
25562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25563                         NDR_PULL_ALLOC(ndr, r->out.needed);
25564                 }
25565                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25566                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25569                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25570                 if (r->out.buffer) {
25571                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
25572                 }
25573         }
25574         return NDR_ERR_SUCCESS;
25575 }
25576
25577 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
25578 {
25579         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
25580         ndr->depth++;
25581         if (flags & NDR_SET_VALUES) {
25582                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25583         }
25584         if (flags & NDR_IN) {
25585                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
25586                 ndr->depth++;
25587                 ndr_print_ptr(ndr, "handle", r->in.handle);
25588                 ndr->depth++;
25589                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25590                 ndr->depth--;
25591                 ndr_print_string(ndr, "key_name", r->in.key_name);
25592                 ndr_print_string(ndr, "value_name", r->in.value_name);
25593                 ndr_print_uint32(ndr, "offered", r->in.offered);
25594                 ndr->depth--;
25595         }
25596         if (flags & NDR_OUT) {
25597                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
25598                 ndr->depth++;
25599                 ndr_print_ptr(ndr, "type", r->out.type);
25600                 ndr->depth++;
25601                 ndr_print_uint32(ndr, "type", *r->out.type);
25602                 ndr->depth--;
25603                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25604                 ndr->depth++;
25605                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
25606                 ndr->depth--;
25607                 ndr_print_ptr(ndr, "needed", r->out.needed);
25608                 ndr->depth++;
25609                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25610                 ndr->depth--;
25611                 ndr_print_WERROR(ndr, "result", r->out.result);
25612                 ndr->depth--;
25613         }
25614         ndr->depth--;
25615 }
25616
25617 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
25618 {
25619         if (flags & NDR_IN) {
25620                 if (r->in.handle == NULL) {
25621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25622                 }
25623                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25627                 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));
25628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25629         }
25630         if (flags & NDR_OUT) {
25631                 if (r->out.buffer == NULL) {
25632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25633                 }
25634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25635                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
25636                 if (r->out.needed == NULL) {
25637                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25638                 }
25639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25640                 if (r->out.count == NULL) {
25641                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25642                 }
25643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25645         }
25646         return NDR_ERR_SUCCESS;
25647 }
25648
25649 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
25650 {
25651         TALLOC_CTX *_mem_save_handle_0;
25652         TALLOC_CTX *_mem_save_needed_0;
25653         TALLOC_CTX *_mem_save_count_0;
25654         if (flags & NDR_IN) {
25655                 ZERO_STRUCT(r->out);
25656
25657                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25658                         NDR_PULL_ALLOC(ndr, r->in.handle);
25659                 }
25660                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25661                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25662                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25664                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25665                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25666                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25667                         return 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));
25668                 }
25669                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25670                 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));
25671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25672                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
25673                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
25674                 NDR_PULL_ALLOC(ndr, r->out.needed);
25675                 ZERO_STRUCTP(r->out.needed);
25676                 NDR_PULL_ALLOC(ndr, r->out.count);
25677                 ZERO_STRUCTP(r->out.count);
25678         }
25679         if (flags & NDR_OUT) {
25680                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
25681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25682                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
25683                 }
25684                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
25685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25686                         NDR_PULL_ALLOC(ndr, r->out.needed);
25687                 }
25688                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25689                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25692                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25693                         NDR_PULL_ALLOC(ndr, r->out.count);
25694                 }
25695                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25696                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25699                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25700                 if (r->out.buffer) {
25701                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
25702                 }
25703         }
25704         return NDR_ERR_SUCCESS;
25705 }
25706
25707 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
25708 {
25709         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
25710         ndr->depth++;
25711         if (flags & NDR_SET_VALUES) {
25712                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25713         }
25714         if (flags & NDR_IN) {
25715                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
25716                 ndr->depth++;
25717                 ndr_print_ptr(ndr, "handle", r->in.handle);
25718                 ndr->depth++;
25719                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25720                 ndr->depth--;
25721                 ndr_print_string(ndr, "key_name", r->in.key_name);
25722                 ndr_print_uint32(ndr, "offered", r->in.offered);
25723                 ndr->depth--;
25724         }
25725         if (flags & NDR_OUT) {
25726                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
25727                 ndr->depth++;
25728                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25729                 ndr->depth++;
25730                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
25731                 ndr->depth--;
25732                 ndr_print_ptr(ndr, "needed", r->out.needed);
25733                 ndr->depth++;
25734                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25735                 ndr->depth--;
25736                 ndr_print_ptr(ndr, "count", r->out.count);
25737                 ndr->depth++;
25738                 ndr_print_uint32(ndr, "count", *r->out.count);
25739                 ndr->depth--;
25740                 ndr_print_WERROR(ndr, "result", r->out.result);
25741                 ndr->depth--;
25742         }
25743         ndr->depth--;
25744 }
25745
25746 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
25747 {
25748         uint32_t cntr_key_buffer_1;
25749         if (flags & NDR_IN) {
25750                 if (r->in.handle == NULL) {
25751                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25752                 }
25753                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25757                 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));
25758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
25759         }
25760         if (flags & NDR_OUT) {
25761                 if (r->out.key_buffer == NULL) {
25762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25763                 }
25764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
25765                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
25766                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
25767                 }
25768                 if (r->out.needed == NULL) {
25769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25770                 }
25771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25772                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25773         }
25774         return NDR_ERR_SUCCESS;
25775 }
25776
25777 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
25778 {
25779         uint32_t cntr_key_buffer_1;
25780         TALLOC_CTX *_mem_save_handle_0;
25781         TALLOC_CTX *_mem_save_key_buffer_1;
25782         TALLOC_CTX *_mem_save_needed_0;
25783         if (flags & NDR_IN) {
25784                 ZERO_STRUCT(r->out);
25785
25786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25787                         NDR_PULL_ALLOC(ndr, r->in.handle);
25788                 }
25789                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25791                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25793                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25794                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25795                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25796                         return 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));
25797                 }
25798                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25799                 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));
25800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
25801                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
25802                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
25803                 NDR_PULL_ALLOC(ndr, r->out.needed);
25804                 ZERO_STRUCTP(r->out.needed);
25805         }
25806         if (flags & NDR_OUT) {
25807                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
25808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25809                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
25810                 }
25811                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
25812                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
25813                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
25814                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
25815                 }
25816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
25817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25818                         NDR_PULL_ALLOC(ndr, r->out.needed);
25819                 }
25820                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25821                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25825                 if (r->out.key_buffer) {
25826                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
25827                 }
25828         }
25829         return NDR_ERR_SUCCESS;
25830 }
25831
25832 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
25833 {
25834         uint32_t cntr_key_buffer_1;
25835         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
25836         ndr->depth++;
25837         if (flags & NDR_SET_VALUES) {
25838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25839         }
25840         if (flags & NDR_IN) {
25841                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
25842                 ndr->depth++;
25843                 ndr_print_ptr(ndr, "handle", r->in.handle);
25844                 ndr->depth++;
25845                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25846                 ndr->depth--;
25847                 ndr_print_string(ndr, "key_name", r->in.key_name);
25848                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
25849                 ndr->depth--;
25850         }
25851         if (flags & NDR_OUT) {
25852                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
25853                 ndr->depth++;
25854                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
25855                 ndr->depth++;
25856                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
25857                 ndr->depth++;
25858                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
25859                         char *idx_1=NULL;
25860                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
25861                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
25862                                 free(idx_1);
25863                         }
25864                 }
25865                 ndr->depth--;
25866                 ndr->depth--;
25867                 ndr_print_ptr(ndr, "needed", r->out.needed);
25868                 ndr->depth++;
25869                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25870                 ndr->depth--;
25871                 ndr_print_WERROR(ndr, "result", r->out.result);
25872                 ndr->depth--;
25873         }
25874         ndr->depth--;
25875 }
25876
25877 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
25878 {
25879         if (flags & NDR_IN) {
25880                 if (r->in.handle == NULL) {
25881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25882                 }
25883                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25887                 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));
25888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25891                 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));
25892         }
25893         if (flags & NDR_OUT) {
25894                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25895         }
25896         return NDR_ERR_SUCCESS;
25897 }
25898
25899 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
25900 {
25901         TALLOC_CTX *_mem_save_handle_0;
25902         if (flags & NDR_IN) {
25903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25904                         NDR_PULL_ALLOC(ndr, r->in.handle);
25905                 }
25906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25910                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25911                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25912                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25913                         return 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));
25914                 }
25915                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25916                 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));
25917                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25918                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25919                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25920                         return 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));
25921                 }
25922                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25923                 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));
25924         }
25925         if (flags & NDR_OUT) {
25926                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25927         }
25928         return NDR_ERR_SUCCESS;
25929 }
25930
25931 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
25932 {
25933         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
25934         ndr->depth++;
25935         if (flags & NDR_SET_VALUES) {
25936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25937         }
25938         if (flags & NDR_IN) {
25939                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
25940                 ndr->depth++;
25941                 ndr_print_ptr(ndr, "handle", r->in.handle);
25942                 ndr->depth++;
25943                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25944                 ndr->depth--;
25945                 ndr_print_string(ndr, "key_name", r->in.key_name);
25946                 ndr_print_string(ndr, "value_name", r->in.value_name);
25947                 ndr->depth--;
25948         }
25949         if (flags & NDR_OUT) {
25950                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
25951                 ndr->depth++;
25952                 ndr_print_WERROR(ndr, "result", r->out.result);
25953                 ndr->depth--;
25954         }
25955         ndr->depth--;
25956 }
25957
25958 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
25959 {
25960         if (flags & NDR_IN) {
25961                 if (r->in.handle == NULL) {
25962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25963                 }
25964                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25968                 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));
25969         }
25970         if (flags & NDR_OUT) {
25971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25972         }
25973         return NDR_ERR_SUCCESS;
25974 }
25975
25976 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
25977 {
25978         TALLOC_CTX *_mem_save_handle_0;
25979         if (flags & NDR_IN) {
25980                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25981                         NDR_PULL_ALLOC(ndr, r->in.handle);
25982                 }
25983                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25984                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25985                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25987                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25988                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25989                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25990                         return 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));
25991                 }
25992                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25993                 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));
25994         }
25995         if (flags & NDR_OUT) {
25996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25997         }
25998         return NDR_ERR_SUCCESS;
25999 }
26000
26001 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26002 {
26003         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26004         ndr->depth++;
26005         if (flags & NDR_SET_VALUES) {
26006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26007         }
26008         if (flags & NDR_IN) {
26009                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26010                 ndr->depth++;
26011                 ndr_print_ptr(ndr, "handle", r->in.handle);
26012                 ndr->depth++;
26013                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26014                 ndr->depth--;
26015                 ndr_print_string(ndr, "key_name", r->in.key_name);
26016                 ndr->depth--;
26017         }
26018         if (flags & NDR_OUT) {
26019                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26020                 ndr->depth++;
26021                 ndr_print_WERROR(ndr, "result", r->out.result);
26022                 ndr->depth--;
26023         }
26024         ndr->depth--;
26025 }
26026
26027 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26028 {
26029         if (flags & NDR_IN) {
26030         }
26031         if (flags & NDR_OUT) {
26032                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26033         }
26034         return NDR_ERR_SUCCESS;
26035 }
26036
26037 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26038 {
26039         if (flags & NDR_IN) {
26040         }
26041         if (flags & NDR_OUT) {
26042                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26043         }
26044         return NDR_ERR_SUCCESS;
26045 }
26046
26047 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26048 {
26049         ndr_print_struct(ndr, name, "spoolss_53");
26050         ndr->depth++;
26051         if (flags & NDR_SET_VALUES) {
26052                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26053         }
26054         if (flags & NDR_IN) {
26055                 ndr_print_struct(ndr, "in", "spoolss_53");
26056                 ndr->depth++;
26057                 ndr->depth--;
26058         }
26059         if (flags & NDR_OUT) {
26060                 ndr_print_struct(ndr, "out", "spoolss_53");
26061                 ndr->depth++;
26062                 ndr_print_WERROR(ndr, "result", r->out.result);
26063                 ndr->depth--;
26064         }
26065         ndr->depth--;
26066 }
26067
26068 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26069 {
26070         if (flags & NDR_IN) {
26071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26072                 if (r->in.server) {
26073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26076                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26077                 }
26078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26081                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26085                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26086                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26088         }
26089         if (flags & NDR_OUT) {
26090                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26091         }
26092         return NDR_ERR_SUCCESS;
26093 }
26094
26095 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26096 {
26097         uint32_t _ptr_server;
26098         TALLOC_CTX *_mem_save_server_0;
26099         if (flags & NDR_IN) {
26100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26101                 if (_ptr_server) {
26102                         NDR_PULL_ALLOC(ndr, r->in.server);
26103                 } else {
26104                         r->in.server = NULL;
26105                 }
26106                 if (r->in.server) {
26107                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26108                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26111                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26112                                 return 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));
26113                         }
26114                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26115                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26117                 }
26118                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26119                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26120                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26121                         return 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));
26122                 }
26123                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26124                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26125                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26126                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26127                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26128                         return 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));
26129                 }
26130                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26131                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26132                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26134         }
26135         if (flags & NDR_OUT) {
26136                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26137         }
26138         return NDR_ERR_SUCCESS;
26139 }
26140
26141 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26142 {
26143         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26144         ndr->depth++;
26145         if (flags & NDR_SET_VALUES) {
26146                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26147         }
26148         if (flags & NDR_IN) {
26149                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26150                 ndr->depth++;
26151                 ndr_print_ptr(ndr, "server", r->in.server);
26152                 ndr->depth++;
26153                 if (r->in.server) {
26154                         ndr_print_string(ndr, "server", r->in.server);
26155                 }
26156                 ndr->depth--;
26157                 ndr_print_string(ndr, "architecture", r->in.architecture);
26158                 ndr_print_string(ndr, "driver", r->in.driver);
26159                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26160                 ndr_print_uint32(ndr, "version", r->in.version);
26161                 ndr->depth--;
26162         }
26163         if (flags & NDR_OUT) {
26164                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26165                 ndr->depth++;
26166                 ndr_print_WERROR(ndr, "result", r->out.result);
26167                 ndr->depth--;
26168         }
26169         ndr->depth--;
26170 }
26171
26172 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26173 {
26174         if (flags & NDR_IN) {
26175         }
26176         if (flags & NDR_OUT) {
26177                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26178         }
26179         return NDR_ERR_SUCCESS;
26180 }
26181
26182 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26183 {
26184         if (flags & NDR_IN) {
26185         }
26186         if (flags & NDR_OUT) {
26187                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26188         }
26189         return NDR_ERR_SUCCESS;
26190 }
26191
26192 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26193 {
26194         ndr_print_struct(ndr, name, "spoolss_55");
26195         ndr->depth++;
26196         if (flags & NDR_SET_VALUES) {
26197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26198         }
26199         if (flags & NDR_IN) {
26200                 ndr_print_struct(ndr, "in", "spoolss_55");
26201                 ndr->depth++;
26202                 ndr->depth--;
26203         }
26204         if (flags & NDR_OUT) {
26205                 ndr_print_struct(ndr, "out", "spoolss_55");
26206                 ndr->depth++;
26207                 ndr_print_WERROR(ndr, "result", r->out.result);
26208                 ndr->depth--;
26209         }
26210         ndr->depth--;
26211 }
26212
26213 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26214 {
26215         if (flags & NDR_IN) {
26216         }
26217         if (flags & NDR_OUT) {
26218                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26219         }
26220         return NDR_ERR_SUCCESS;
26221 }
26222
26223 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26224 {
26225         if (flags & NDR_IN) {
26226         }
26227         if (flags & NDR_OUT) {
26228                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26229         }
26230         return NDR_ERR_SUCCESS;
26231 }
26232
26233 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26234 {
26235         ndr_print_struct(ndr, name, "spoolss_56");
26236         ndr->depth++;
26237         if (flags & NDR_SET_VALUES) {
26238                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26239         }
26240         if (flags & NDR_IN) {
26241                 ndr_print_struct(ndr, "in", "spoolss_56");
26242                 ndr->depth++;
26243                 ndr->depth--;
26244         }
26245         if (flags & NDR_OUT) {
26246                 ndr_print_struct(ndr, "out", "spoolss_56");
26247                 ndr->depth++;
26248                 ndr_print_WERROR(ndr, "result", r->out.result);
26249                 ndr->depth--;
26250         }
26251         ndr->depth--;
26252 }
26253
26254 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26255 {
26256         if (flags & NDR_IN) {
26257         }
26258         if (flags & NDR_OUT) {
26259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26260         }
26261         return NDR_ERR_SUCCESS;
26262 }
26263
26264 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26265 {
26266         if (flags & NDR_IN) {
26267         }
26268         if (flags & NDR_OUT) {
26269                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26270         }
26271         return NDR_ERR_SUCCESS;
26272 }
26273
26274 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26275 {
26276         ndr_print_struct(ndr, name, "spoolss_57");
26277         ndr->depth++;
26278         if (flags & NDR_SET_VALUES) {
26279                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26280         }
26281         if (flags & NDR_IN) {
26282                 ndr_print_struct(ndr, "in", "spoolss_57");
26283                 ndr->depth++;
26284                 ndr->depth--;
26285         }
26286         if (flags & NDR_OUT) {
26287                 ndr_print_struct(ndr, "out", "spoolss_57");
26288                 ndr->depth++;
26289                 ndr_print_WERROR(ndr, "result", r->out.result);
26290                 ndr->depth--;
26291         }
26292         ndr->depth--;
26293 }
26294
26295 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26296 {
26297         if (flags & NDR_IN) {
26298                 if (r->in.handle == NULL) {
26299                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26300                 }
26301                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26305                 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));
26306                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26309                 if (r->in.status_code == NULL) {
26310                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26311                 }
26312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26313         }
26314         if (flags & NDR_OUT) {
26315                 if (r->out.out_data == NULL) {
26316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26317                 }
26318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26319                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26320                 if (r->out.needed == NULL) {
26321                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26322                 }
26323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26324                 if (r->out.status_code == NULL) {
26325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26326                 }
26327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26328                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26329         }
26330         return NDR_ERR_SUCCESS;
26331 }
26332
26333 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26334 {
26335         TALLOC_CTX *_mem_save_handle_0;
26336         TALLOC_CTX *_mem_save_needed_0;
26337         TALLOC_CTX *_mem_save_status_code_0;
26338         if (flags & NDR_IN) {
26339                 ZERO_STRUCT(r->out);
26340
26341                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26342                         NDR_PULL_ALLOC(ndr, r->in.handle);
26343                 }
26344                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26345                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26346                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26347                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26348                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26349                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26350                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26351                         return 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));
26352                 }
26353                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26354                 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));
26355                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26358                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26359                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26360                 }
26361                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26362                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26365                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26366                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26367                 NDR_PULL_ALLOC(ndr, r->out.needed);
26368                 ZERO_STRUCTP(r->out.needed);
26369                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26370                 *r->out.status_code = *r->in.status_code;
26371         }
26372         if (flags & NDR_OUT) {
26373                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26375                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26376                 }
26377                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26379                         NDR_PULL_ALLOC(ndr, r->out.needed);
26380                 }
26381                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26382                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26386                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26387                 }
26388                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26392                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26393                 if (r->out.out_data) {
26394                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26395                 }
26396         }
26397         return NDR_ERR_SUCCESS;
26398 }
26399
26400 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26401 {
26402         ndr_print_struct(ndr, name, "spoolss_XcvData");
26403         ndr->depth++;
26404         if (flags & NDR_SET_VALUES) {
26405                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26406         }
26407         if (flags & NDR_IN) {
26408                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26409                 ndr->depth++;
26410                 ndr_print_ptr(ndr, "handle", r->in.handle);
26411                 ndr->depth++;
26412                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26413                 ndr->depth--;
26414                 ndr_print_string(ndr, "function_name", r->in.function_name);
26415                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26416                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26417                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26418                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26419                 ndr->depth++;
26420                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26421                 ndr->depth--;
26422                 ndr->depth--;
26423         }
26424         if (flags & NDR_OUT) {
26425                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26426                 ndr->depth++;
26427                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26428                 ndr->depth++;
26429                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26430                 ndr->depth--;
26431                 ndr_print_ptr(ndr, "needed", r->out.needed);
26432                 ndr->depth++;
26433                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26434                 ndr->depth--;
26435                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26436                 ndr->depth++;
26437                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26438                 ndr->depth--;
26439                 ndr_print_WERROR(ndr, "result", r->out.result);
26440                 ndr->depth--;
26441         }
26442         ndr->depth--;
26443 }
26444
26445 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26446 {
26447         if (flags & NDR_IN) {
26448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26449                 if (r->in.servername) {
26450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26454                 }
26455                 if (r->in.info_ctr == NULL) {
26456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26457                 }
26458                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26459                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26460         }
26461         if (flags & NDR_OUT) {
26462                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26463         }
26464         return NDR_ERR_SUCCESS;
26465 }
26466
26467 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
26468 {
26469         uint32_t _ptr_servername;
26470         TALLOC_CTX *_mem_save_servername_0;
26471         TALLOC_CTX *_mem_save_info_ctr_0;
26472         if (flags & NDR_IN) {
26473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26474                 if (_ptr_servername) {
26475                         NDR_PULL_ALLOC(ndr, r->in.servername);
26476                 } else {
26477                         r->in.servername = NULL;
26478                 }
26479                 if (r->in.servername) {
26480                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26481                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26482                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26483                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26484                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26485                                 return 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));
26486                         }
26487                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26488                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26490                 }
26491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26492                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26493                 }
26494                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26495                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26496                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26498                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
26499         }
26500         if (flags & NDR_OUT) {
26501                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26502         }
26503         return NDR_ERR_SUCCESS;
26504 }
26505
26506 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
26507 {
26508         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
26509         ndr->depth++;
26510         if (flags & NDR_SET_VALUES) {
26511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26512         }
26513         if (flags & NDR_IN) {
26514                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
26515                 ndr->depth++;
26516                 ndr_print_ptr(ndr, "servername", r->in.servername);
26517                 ndr->depth++;
26518                 if (r->in.servername) {
26519                         ndr_print_string(ndr, "servername", r->in.servername);
26520                 }
26521                 ndr->depth--;
26522                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26523                 ndr->depth++;
26524                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26525                 ndr->depth--;
26526                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
26527                 ndr->depth--;
26528         }
26529         if (flags & NDR_OUT) {
26530                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
26531                 ndr->depth++;
26532                 ndr_print_WERROR(ndr, "result", r->out.result);
26533                 ndr->depth--;
26534         }
26535         ndr->depth--;
26536 }
26537
26538 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
26539 {
26540         if (flags & NDR_IN) {
26541         }
26542         if (flags & NDR_OUT) {
26543                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26544         }
26545         return NDR_ERR_SUCCESS;
26546 }
26547
26548 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
26549 {
26550         if (flags & NDR_IN) {
26551         }
26552         if (flags & NDR_OUT) {
26553                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26554         }
26555         return NDR_ERR_SUCCESS;
26556 }
26557
26558 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
26559 {
26560         ndr_print_struct(ndr, name, "spoolss_5a");
26561         ndr->depth++;
26562         if (flags & NDR_SET_VALUES) {
26563                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26564         }
26565         if (flags & NDR_IN) {
26566                 ndr_print_struct(ndr, "in", "spoolss_5a");
26567                 ndr->depth++;
26568                 ndr->depth--;
26569         }
26570         if (flags & NDR_OUT) {
26571                 ndr_print_struct(ndr, "out", "spoolss_5a");
26572                 ndr->depth++;
26573                 ndr_print_WERROR(ndr, "result", r->out.result);
26574                 ndr->depth--;
26575         }
26576         ndr->depth--;
26577 }
26578
26579 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
26580 {
26581         if (flags & NDR_IN) {
26582         }
26583         if (flags & NDR_OUT) {
26584                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26585         }
26586         return NDR_ERR_SUCCESS;
26587 }
26588
26589 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
26590 {
26591         if (flags & NDR_IN) {
26592         }
26593         if (flags & NDR_OUT) {
26594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26595         }
26596         return NDR_ERR_SUCCESS;
26597 }
26598
26599 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
26600 {
26601         ndr_print_struct(ndr, name, "spoolss_5b");
26602         ndr->depth++;
26603         if (flags & NDR_SET_VALUES) {
26604                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26605         }
26606         if (flags & NDR_IN) {
26607                 ndr_print_struct(ndr, "in", "spoolss_5b");
26608                 ndr->depth++;
26609                 ndr->depth--;
26610         }
26611         if (flags & NDR_OUT) {
26612                 ndr_print_struct(ndr, "out", "spoolss_5b");
26613                 ndr->depth++;
26614                 ndr_print_WERROR(ndr, "result", r->out.result);
26615                 ndr->depth--;
26616         }
26617         ndr->depth--;
26618 }
26619
26620 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
26621 {
26622         if (flags & NDR_IN) {
26623         }
26624         if (flags & NDR_OUT) {
26625                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26626         }
26627         return NDR_ERR_SUCCESS;
26628 }
26629
26630 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
26631 {
26632         if (flags & NDR_IN) {
26633         }
26634         if (flags & NDR_OUT) {
26635                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26636         }
26637         return NDR_ERR_SUCCESS;
26638 }
26639
26640 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
26641 {
26642         ndr_print_struct(ndr, name, "spoolss_5c");
26643         ndr->depth++;
26644         if (flags & NDR_SET_VALUES) {
26645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26646         }
26647         if (flags & NDR_IN) {
26648                 ndr_print_struct(ndr, "in", "spoolss_5c");
26649                 ndr->depth++;
26650                 ndr->depth--;
26651         }
26652         if (flags & NDR_OUT) {
26653                 ndr_print_struct(ndr, "out", "spoolss_5c");
26654                 ndr->depth++;
26655                 ndr_print_WERROR(ndr, "result", r->out.result);
26656                 ndr->depth--;
26657         }
26658         ndr->depth--;
26659 }
26660
26661 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
26662 {
26663         if (flags & NDR_IN) {
26664         }
26665         if (flags & NDR_OUT) {
26666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26667         }
26668         return NDR_ERR_SUCCESS;
26669 }
26670
26671 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
26672 {
26673         if (flags & NDR_IN) {
26674         }
26675         if (flags & NDR_OUT) {
26676                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26677         }
26678         return NDR_ERR_SUCCESS;
26679 }
26680
26681 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
26682 {
26683         ndr_print_struct(ndr, name, "spoolss_5d");
26684         ndr->depth++;
26685         if (flags & NDR_SET_VALUES) {
26686                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26687         }
26688         if (flags & NDR_IN) {
26689                 ndr_print_struct(ndr, "in", "spoolss_5d");
26690                 ndr->depth++;
26691                 ndr->depth--;
26692         }
26693         if (flags & NDR_OUT) {
26694                 ndr_print_struct(ndr, "out", "spoolss_5d");
26695                 ndr->depth++;
26696                 ndr_print_WERROR(ndr, "result", r->out.result);
26697                 ndr->depth--;
26698         }
26699         ndr->depth--;
26700 }
26701
26702 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
26703 {
26704         if (flags & NDR_IN) {
26705         }
26706         if (flags & NDR_OUT) {
26707                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26708         }
26709         return NDR_ERR_SUCCESS;
26710 }
26711
26712 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
26713 {
26714         if (flags & NDR_IN) {
26715         }
26716         if (flags & NDR_OUT) {
26717                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26718         }
26719         return NDR_ERR_SUCCESS;
26720 }
26721
26722 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
26723 {
26724         ndr_print_struct(ndr, name, "spoolss_5e");
26725         ndr->depth++;
26726         if (flags & NDR_SET_VALUES) {
26727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26728         }
26729         if (flags & NDR_IN) {
26730                 ndr_print_struct(ndr, "in", "spoolss_5e");
26731                 ndr->depth++;
26732                 ndr->depth--;
26733         }
26734         if (flags & NDR_OUT) {
26735                 ndr_print_struct(ndr, "out", "spoolss_5e");
26736                 ndr->depth++;
26737                 ndr_print_WERROR(ndr, "result", r->out.result);
26738                 ndr->depth--;
26739         }
26740         ndr->depth--;
26741 }
26742
26743 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
26744 {
26745         if (flags & NDR_IN) {
26746         }
26747         if (flags & NDR_OUT) {
26748                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26749         }
26750         return NDR_ERR_SUCCESS;
26751 }
26752
26753 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
26754 {
26755         if (flags & NDR_IN) {
26756         }
26757         if (flags & NDR_OUT) {
26758                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26759         }
26760         return NDR_ERR_SUCCESS;
26761 }
26762
26763 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
26764 {
26765         ndr_print_struct(ndr, name, "spoolss_5f");
26766         ndr->depth++;
26767         if (flags & NDR_SET_VALUES) {
26768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26769         }
26770         if (flags & NDR_IN) {
26771                 ndr_print_struct(ndr, "in", "spoolss_5f");
26772                 ndr->depth++;
26773                 ndr->depth--;
26774         }
26775         if (flags & NDR_OUT) {
26776                 ndr_print_struct(ndr, "out", "spoolss_5f");
26777                 ndr->depth++;
26778                 ndr_print_WERROR(ndr, "result", r->out.result);
26779                 ndr->depth--;
26780         }
26781         ndr->depth--;
26782 }
26783
26784 static const struct ndr_interface_call spoolss_calls[] = {
26785         {
26786                 "spoolss_EnumPrinters",
26787                 sizeof(struct spoolss_EnumPrinters),
26788                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
26789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
26790                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
26791                 false,
26792         },
26793         {
26794                 "spoolss_OpenPrinter",
26795                 sizeof(struct spoolss_OpenPrinter),
26796                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
26797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
26798                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
26799                 false,
26800         },
26801         {
26802                 "spoolss_SetJob",
26803                 sizeof(struct spoolss_SetJob),
26804                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
26805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
26806                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
26807                 false,
26808         },
26809         {
26810                 "spoolss_GetJob",
26811                 sizeof(struct spoolss_GetJob),
26812                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
26813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
26814                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
26815                 false,
26816         },
26817         {
26818                 "spoolss_EnumJobs",
26819                 sizeof(struct spoolss_EnumJobs),
26820                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
26821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
26822                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
26823                 false,
26824         },
26825         {
26826                 "spoolss_AddPrinter",
26827                 sizeof(struct spoolss_AddPrinter),
26828                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
26829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
26830                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
26831                 false,
26832         },
26833         {
26834                 "spoolss_DeletePrinter",
26835                 sizeof(struct spoolss_DeletePrinter),
26836                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
26837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
26838                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
26839                 false,
26840         },
26841         {
26842                 "spoolss_SetPrinter",
26843                 sizeof(struct spoolss_SetPrinter),
26844                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
26845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
26846                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
26847                 false,
26848         },
26849         {
26850                 "spoolss_GetPrinter",
26851                 sizeof(struct spoolss_GetPrinter),
26852                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
26853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
26854                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
26855                 false,
26856         },
26857         {
26858                 "spoolss_AddPrinterDriver",
26859                 sizeof(struct spoolss_AddPrinterDriver),
26860                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
26861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
26862                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
26863                 false,
26864         },
26865         {
26866                 "spoolss_EnumPrinterDrivers",
26867                 sizeof(struct spoolss_EnumPrinterDrivers),
26868                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
26869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
26870                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
26871                 false,
26872         },
26873         {
26874                 "spoolss_GetPrinterDriver",
26875                 sizeof(struct spoolss_GetPrinterDriver),
26876                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
26877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
26878                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
26879                 false,
26880         },
26881         {
26882                 "spoolss_GetPrinterDriverDirectory",
26883                 sizeof(struct spoolss_GetPrinterDriverDirectory),
26884                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
26885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
26886                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
26887                 false,
26888         },
26889         {
26890                 "spoolss_DeletePrinterDriver",
26891                 sizeof(struct spoolss_DeletePrinterDriver),
26892                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
26893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
26894                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
26895                 false,
26896         },
26897         {
26898                 "spoolss_AddPrintProcessor",
26899                 sizeof(struct spoolss_AddPrintProcessor),
26900                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
26901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
26902                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
26903                 false,
26904         },
26905         {
26906                 "spoolss_EnumPrintProcessors",
26907                 sizeof(struct spoolss_EnumPrintProcessors),
26908                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
26909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
26910                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
26911                 false,
26912         },
26913         {
26914                 "spoolss_GetPrintProcessorDirectory",
26915                 sizeof(struct spoolss_GetPrintProcessorDirectory),
26916                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
26917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
26918                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
26919                 false,
26920         },
26921         {
26922                 "spoolss_StartDocPrinter",
26923                 sizeof(struct spoolss_StartDocPrinter),
26924                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
26925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
26926                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
26927                 false,
26928         },
26929         {
26930                 "spoolss_StartPagePrinter",
26931                 sizeof(struct spoolss_StartPagePrinter),
26932                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
26933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
26934                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
26935                 false,
26936         },
26937         {
26938                 "spoolss_WritePrinter",
26939                 sizeof(struct spoolss_WritePrinter),
26940                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
26941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
26942                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
26943                 false,
26944         },
26945         {
26946                 "spoolss_EndPagePrinter",
26947                 sizeof(struct spoolss_EndPagePrinter),
26948                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
26949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
26950                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
26951                 false,
26952         },
26953         {
26954                 "spoolss_AbortPrinter",
26955                 sizeof(struct spoolss_AbortPrinter),
26956                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
26957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
26958                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
26959                 false,
26960         },
26961         {
26962                 "spoolss_ReadPrinter",
26963                 sizeof(struct spoolss_ReadPrinter),
26964                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
26965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
26966                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
26967                 false,
26968         },
26969         {
26970                 "spoolss_EndDocPrinter",
26971                 sizeof(struct spoolss_EndDocPrinter),
26972                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
26973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
26974                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
26975                 false,
26976         },
26977         {
26978                 "spoolss_AddJob",
26979                 sizeof(struct spoolss_AddJob),
26980                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
26981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
26982                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
26983                 false,
26984         },
26985         {
26986                 "spoolss_ScheduleJob",
26987                 sizeof(struct spoolss_ScheduleJob),
26988                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
26989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
26990                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
26991                 false,
26992         },
26993         {
26994                 "spoolss_GetPrinterData",
26995                 sizeof(struct spoolss_GetPrinterData),
26996                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
26997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
26998                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
26999                 false,
27000         },
27001         {
27002                 "spoolss_SetPrinterData",
27003                 sizeof(struct spoolss_SetPrinterData),
27004                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27006                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27007                 false,
27008         },
27009         {
27010                 "spoolss_WaitForPrinterChange",
27011                 sizeof(struct spoolss_WaitForPrinterChange),
27012                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27014                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27015                 false,
27016         },
27017         {
27018                 "spoolss_ClosePrinter",
27019                 sizeof(struct spoolss_ClosePrinter),
27020                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27022                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27023                 false,
27024         },
27025         {
27026                 "spoolss_AddForm",
27027                 sizeof(struct spoolss_AddForm),
27028                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27030                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27031                 false,
27032         },
27033         {
27034                 "spoolss_DeleteForm",
27035                 sizeof(struct spoolss_DeleteForm),
27036                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27038                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27039                 false,
27040         },
27041         {
27042                 "spoolss_GetForm",
27043                 sizeof(struct spoolss_GetForm),
27044                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27046                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27047                 false,
27048         },
27049         {
27050                 "spoolss_SetForm",
27051                 sizeof(struct spoolss_SetForm),
27052                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27054                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27055                 false,
27056         },
27057         {
27058                 "spoolss_EnumForms",
27059                 sizeof(struct spoolss_EnumForms),
27060                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27062                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27063                 false,
27064         },
27065         {
27066                 "spoolss_EnumPorts",
27067                 sizeof(struct spoolss_EnumPorts),
27068                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27070                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27071                 false,
27072         },
27073         {
27074                 "spoolss_EnumMonitors",
27075                 sizeof(struct spoolss_EnumMonitors),
27076                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27078                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27079                 false,
27080         },
27081         {
27082                 "spoolss_AddPort",
27083                 sizeof(struct spoolss_AddPort),
27084                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27086                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27087                 false,
27088         },
27089         {
27090                 "spoolss_ConfigurePort",
27091                 sizeof(struct spoolss_ConfigurePort),
27092                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27094                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27095                 false,
27096         },
27097         {
27098                 "spoolss_DeletePort",
27099                 sizeof(struct spoolss_DeletePort),
27100                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27102                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27103                 false,
27104         },
27105         {
27106                 "spoolss_CreatePrinterIC",
27107                 sizeof(struct spoolss_CreatePrinterIC),
27108                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27110                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27111                 false,
27112         },
27113         {
27114                 "spoolss_PlayGDIScriptOnPrinterIC",
27115                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27116                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27118                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27119                 false,
27120         },
27121         {
27122                 "spoolss_DeletePrinterIC",
27123                 sizeof(struct spoolss_DeletePrinterIC),
27124                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27126                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27127                 false,
27128         },
27129         {
27130                 "spoolss_AddPrinterConnection",
27131                 sizeof(struct spoolss_AddPrinterConnection),
27132                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27134                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27135                 false,
27136         },
27137         {
27138                 "spoolss_DeletePrinterConnection",
27139                 sizeof(struct spoolss_DeletePrinterConnection),
27140                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27142                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27143                 false,
27144         },
27145         {
27146                 "spoolss_PrinterMessageBox",
27147                 sizeof(struct spoolss_PrinterMessageBox),
27148                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27150                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27151                 false,
27152         },
27153         {
27154                 "spoolss_AddMonitor",
27155                 sizeof(struct spoolss_AddMonitor),
27156                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27158                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27159                 false,
27160         },
27161         {
27162                 "spoolss_DeleteMonitor",
27163                 sizeof(struct spoolss_DeleteMonitor),
27164                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27166                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27167                 false,
27168         },
27169         {
27170                 "spoolss_DeletePrintProcessor",
27171                 sizeof(struct spoolss_DeletePrintProcessor),
27172                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27174                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27175                 false,
27176         },
27177         {
27178                 "spoolss_AddPrintProvidor",
27179                 sizeof(struct spoolss_AddPrintProvidor),
27180                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27182                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27183                 false,
27184         },
27185         {
27186                 "spoolss_DeletePrintProvidor",
27187                 sizeof(struct spoolss_DeletePrintProvidor),
27188                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27190                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27191                 false,
27192         },
27193         {
27194                 "spoolss_EnumPrintProcDataTypes",
27195                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27196                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27198                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27199                 false,
27200         },
27201         {
27202                 "spoolss_ResetPrinter",
27203                 sizeof(struct spoolss_ResetPrinter),
27204                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27206                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27207                 false,
27208         },
27209         {
27210                 "spoolss_GetPrinterDriver2",
27211                 sizeof(struct spoolss_GetPrinterDriver2),
27212                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27214                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27215                 false,
27216         },
27217         {
27218                 "spoolss_FindFirstPrinterChangeNotification",
27219                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27220                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27222                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27223                 false,
27224         },
27225         {
27226                 "spoolss_FindNextPrinterChangeNotification",
27227                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27228                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27230                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27231                 false,
27232         },
27233         {
27234                 "spoolss_FindClosePrinterNotify",
27235                 sizeof(struct spoolss_FindClosePrinterNotify),
27236                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27238                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27239                 false,
27240         },
27241         {
27242                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27243                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27244                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27246                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27247                 false,
27248         },
27249         {
27250                 "spoolss_ReplyOpenPrinter",
27251                 sizeof(struct spoolss_ReplyOpenPrinter),
27252                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27254                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27255                 false,
27256         },
27257         {
27258                 "spoolss_RouterReplyPrinter",
27259                 sizeof(struct spoolss_RouterReplyPrinter),
27260                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27262                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27263                 false,
27264         },
27265         {
27266                 "spoolss_ReplyClosePrinter",
27267                 sizeof(struct spoolss_ReplyClosePrinter),
27268                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27270                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27271                 false,
27272         },
27273         {
27274                 "spoolss_AddPortEx",
27275                 sizeof(struct spoolss_AddPortEx),
27276                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27278                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27279                 false,
27280         },
27281         {
27282                 "spoolss_RouterFindFirstPrinterChangeNotification",
27283                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27284                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27286                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27287                 false,
27288         },
27289         {
27290                 "spoolss_SpoolerInit",
27291                 sizeof(struct spoolss_SpoolerInit),
27292                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27294                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27295                 false,
27296         },
27297         {
27298                 "spoolss_ResetPrinterEx",
27299                 sizeof(struct spoolss_ResetPrinterEx),
27300                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27302                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27303                 false,
27304         },
27305         {
27306                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27307                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27308                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27310                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27311                 false,
27312         },
27313         {
27314                 "spoolss_RouterReplyPrinterEx",
27315                 sizeof(struct spoolss_RouterReplyPrinterEx),
27316                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27318                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27319                 false,
27320         },
27321         {
27322                 "spoolss_RouterRefreshPrinterChangeNotify",
27323                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27324                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27326                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27327                 false,
27328         },
27329         {
27330                 "spoolss_44",
27331                 sizeof(struct spoolss_44),
27332                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27334                 (ndr_print_function_t) ndr_print_spoolss_44,
27335                 false,
27336         },
27337         {
27338                 "spoolss_OpenPrinterEx",
27339                 sizeof(struct spoolss_OpenPrinterEx),
27340                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27342                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27343                 false,
27344         },
27345         {
27346                 "spoolss_AddPrinterEx",
27347                 sizeof(struct spoolss_AddPrinterEx),
27348                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27350                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27351                 false,
27352         },
27353         {
27354                 "spoolss_47",
27355                 sizeof(struct spoolss_47),
27356                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27358                 (ndr_print_function_t) ndr_print_spoolss_47,
27359                 false,
27360         },
27361         {
27362                 "spoolss_EnumPrinterData",
27363                 sizeof(struct spoolss_EnumPrinterData),
27364                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27366                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27367                 false,
27368         },
27369         {
27370                 "spoolss_DeletePrinterData",
27371                 sizeof(struct spoolss_DeletePrinterData),
27372                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27374                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27375                 false,
27376         },
27377         {
27378                 "spoolss_4a",
27379                 sizeof(struct spoolss_4a),
27380                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27382                 (ndr_print_function_t) ndr_print_spoolss_4a,
27383                 false,
27384         },
27385         {
27386                 "spoolss_4b",
27387                 sizeof(struct spoolss_4b),
27388                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27390                 (ndr_print_function_t) ndr_print_spoolss_4b,
27391                 false,
27392         },
27393         {
27394                 "spoolss_4c",
27395                 sizeof(struct spoolss_4c),
27396                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27398                 (ndr_print_function_t) ndr_print_spoolss_4c,
27399                 false,
27400         },
27401         {
27402                 "spoolss_SetPrinterDataEx",
27403                 sizeof(struct spoolss_SetPrinterDataEx),
27404                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27406                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27407                 false,
27408         },
27409         {
27410                 "spoolss_GetPrinterDataEx",
27411                 sizeof(struct spoolss_GetPrinterDataEx),
27412                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27414                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27415                 false,
27416         },
27417         {
27418                 "spoolss_EnumPrinterDataEx",
27419                 sizeof(struct spoolss_EnumPrinterDataEx),
27420                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27422                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27423                 false,
27424         },
27425         {
27426                 "spoolss_EnumPrinterKey",
27427                 sizeof(struct spoolss_EnumPrinterKey),
27428                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27430                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27431                 false,
27432         },
27433         {
27434                 "spoolss_DeletePrinterDataEx",
27435                 sizeof(struct spoolss_DeletePrinterDataEx),
27436                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27438                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27439                 false,
27440         },
27441         {
27442                 "spoolss_DeletePrinterKey",
27443                 sizeof(struct spoolss_DeletePrinterKey),
27444                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27446                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27447                 false,
27448         },
27449         {
27450                 "spoolss_53",
27451                 sizeof(struct spoolss_53),
27452                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27454                 (ndr_print_function_t) ndr_print_spoolss_53,
27455                 false,
27456         },
27457         {
27458                 "spoolss_DeletePrinterDriverEx",
27459                 sizeof(struct spoolss_DeletePrinterDriverEx),
27460                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27462                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27463                 false,
27464         },
27465         {
27466                 "spoolss_55",
27467                 sizeof(struct spoolss_55),
27468                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
27469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
27470                 (ndr_print_function_t) ndr_print_spoolss_55,
27471                 false,
27472         },
27473         {
27474                 "spoolss_56",
27475                 sizeof(struct spoolss_56),
27476                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
27477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
27478                 (ndr_print_function_t) ndr_print_spoolss_56,
27479                 false,
27480         },
27481         {
27482                 "spoolss_57",
27483                 sizeof(struct spoolss_57),
27484                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
27485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
27486                 (ndr_print_function_t) ndr_print_spoolss_57,
27487                 false,
27488         },
27489         {
27490                 "spoolss_XcvData",
27491                 sizeof(struct spoolss_XcvData),
27492                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
27493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
27494                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
27495                 false,
27496         },
27497         {
27498                 "spoolss_AddPrinterDriverEx",
27499                 sizeof(struct spoolss_AddPrinterDriverEx),
27500                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
27501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
27502                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
27503                 false,
27504         },
27505         {
27506                 "spoolss_5a",
27507                 sizeof(struct spoolss_5a),
27508                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
27509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
27510                 (ndr_print_function_t) ndr_print_spoolss_5a,
27511                 false,
27512         },
27513         {
27514                 "spoolss_5b",
27515                 sizeof(struct spoolss_5b),
27516                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
27517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
27518                 (ndr_print_function_t) ndr_print_spoolss_5b,
27519                 false,
27520         },
27521         {
27522                 "spoolss_5c",
27523                 sizeof(struct spoolss_5c),
27524                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
27525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
27526                 (ndr_print_function_t) ndr_print_spoolss_5c,
27527                 false,
27528         },
27529         {
27530                 "spoolss_5d",
27531                 sizeof(struct spoolss_5d),
27532                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
27533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
27534                 (ndr_print_function_t) ndr_print_spoolss_5d,
27535                 false,
27536         },
27537         {
27538                 "spoolss_5e",
27539                 sizeof(struct spoolss_5e),
27540                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
27541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
27542                 (ndr_print_function_t) ndr_print_spoolss_5e,
27543                 false,
27544         },
27545         {
27546                 "spoolss_5f",
27547                 sizeof(struct spoolss_5f),
27548                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
27549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
27550                 (ndr_print_function_t) ndr_print_spoolss_5f,
27551                 false,
27552         },
27553         { NULL, 0, NULL, NULL, NULL, false }
27554 };
27555
27556 static const char * const spoolss_endpoint_strings[] = {
27557         "ncacn_np:[\\pipe\\spoolss]",
27558 };
27559
27560 static const struct ndr_interface_string_array spoolss_endpoints = {
27561         .count  = 1,
27562         .names  = spoolss_endpoint_strings
27563 };
27564
27565 static const char * const spoolss_authservice_strings[] = {
27566         "host",
27567 };
27568
27569 static const struct ndr_interface_string_array spoolss_authservices = {
27570         .count  = 1,
27571         .names  = spoolss_authservice_strings
27572 };
27573
27574
27575 const struct ndr_interface_table ndr_table_spoolss = {
27576         .name           = "spoolss",
27577         .syntax_id      = {
27578                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
27579                 NDR_SPOOLSS_VERSION
27580         },
27581         .helpstring     = NDR_SPOOLSS_HELPSTRING,
27582         .num_calls      = 96,
27583         .calls          = spoolss_calls,
27584         .endpoints      = &spoolss_endpoints,
27585         .authservices   = &spoolss_authservices
27586 };
27587